28#include "clang/Sema/CodeCompleteConsumer.h"
29#include "clang/Tooling/CompilationDatabase.h"
30#include "llvm/ADT/StringRef.h"
31#include "llvm/Support/Error.h"
32#include "llvm/Support/Path.h"
33#include "llvm/Testing/Annotations/Annotations.h"
34#include "llvm/Testing/Support/Error.h"
35#include "llvm/Testing/Support/SupportHelpers.h"
36#include "gmock/gmock.h"
37#include "gtest/gtest.h"
38#include <condition_variable>
48using ::testing::AllOf;
49using ::testing::Contains;
50using ::testing::ElementsAre;
51using ::testing::Field;
52using ::testing::HasSubstr;
53using ::testing::IsEmpty;
55using ::testing::UnorderedElementsAre;
56using ContextKind = CodeCompletionContext::Kind;
59MATCHER_P(named, Name,
"") {
return arg.Name == Name; }
60MATCHER_P(mainFileRefs, Refs,
"") {
return arg.MainFileRefs == Refs; }
61MATCHER_P(scopeRefs, Refs,
"") {
return arg.ScopeRefsInFile == Refs; }
63 return llvm::StringRef(arg.Name).starts_with(Prefix);
65MATCHER_P(filterText, F,
"") {
return arg.FilterText == F; }
66MATCHER_P(scope, S,
"") {
return arg.Scope == S; }
67MATCHER_P(qualifier, Q,
"") {
return arg.RequiredQualifier == Q; }
69 return arg.RequiredQualifier + arg.Name + arg.Signature ==
Label;
72MATCHER_P(kind, K,
"") {
return arg.Kind == K; }
74 return arg.Documentation && arg.Documentation->asPlainText() ==
D;
76MATCHER_P(returnType, D,
"") {
return arg.ReturnType ==
D; }
78 return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader;
80MATCHER_P(insertInclude, IncludeHeader,
"") {
81 return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader &&
82 bool(arg.Includes[0].Insertion);
84MATCHER_P(insertIncludeText, InsertedText,
"") {
85 return !arg.Includes.empty() && arg.Includes[0].Insertion &&
86 arg.Includes[0].Insertion->newText == InsertedText;
89 return !arg.Includes.empty() && bool(arg.Includes[0].Insertion);
92MATCHER_P(origin, OriginSet,
"") {
return arg.Origin == OriginSet; }
93MATCHER_P(signature, S,
"") {
return arg.Signature == S; }
95 return arg.CompletionTokenRange ==
Range;
99Matcher<const std::vector<CodeCompletion> &> has(std::string Name) {
100 return Contains(named(std::move(Name)));
102Matcher<const std::vector<CodeCompletion> &> has(std::string Name,
104 return Contains(AllOf(named(std::move(Name)), kind(K)));
106MATCHER(isDocumented,
"") {
return arg.Documentation.has_value(); }
107MATCHER(deprecated,
"") {
return arg.Deprecated; }
109std::unique_ptr<SymbolIndex> memIndex(std::vector<Symbol>
Symbols) {
111 for (
const auto &Sym :
Symbols)
119 std::vector<Symbol> IndexSymbols = {},
120 clangd::CodeCompleteOptions Opts = {}) {
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();
129 auto Inputs = TU.inputs(FS);
133 ADD_FAILURE() <<
"Couldn't build CompilerInvocation";
143CodeCompleteResult completions(llvm::StringRef
Text,
144 std::vector<Symbol> IndexSymbols = {},
145 clangd::CodeCompleteOptions Opts = {},
146 PathRef FilePath =
"foo.cpp") {
150 TU.Filename = FilePath.str();
151 return completions(TU, Test.point(), std::move(IndexSymbols),
156CodeCompleteResult completionsNoCompile(llvm::StringRef
Text,
157 std::vector<Symbol> IndexSymbols = {},
158 clangd::CodeCompleteOptions Opts = {},
159 PathRef FilePath =
"foo.cpp") {
160 std::unique_ptr<SymbolIndex> OverrideIndex;
161 if (!IndexSymbols.empty()) {
162 assert(!Opts.Index &&
"both Index and IndexSymbols given!");
163 OverrideIndex = memIndex(std::move(IndexSymbols));
164 Opts.Index = OverrideIndex.get();
169 ParseInputs ParseInput{tooling::CompileCommand(), &FS, Test.code().str()};
170 return codeComplete(FilePath, Test.point(),
nullptr, ParseInput,
179#if CLANGD_DECISION_FOREST
180TEST(DecisionForestRankingModel, NameMatchSanityTest) {
181 clangd::CodeCompleteOptions Opts;
182 Opts.RankingModel = CodeCompleteOptions::DecisionForest;
183 auto Results = completions(
187 int AlphaBetaGamma();
189int func() { MemberAccess().ABG^ }
192 EXPECT_THAT(Results.Completions,
193 ElementsAre(named(
"ABG"), named(
"AlphaBetaGamma")));
196TEST(DecisionForestRankingModel, ReferencesAffectRanking) {
197 clangd::CodeCompleteOptions Opts;
198 Opts.RankingModel = CodeCompleteOptions::DecisionForest;
199 constexpr int NumReferences = 100000;
201 completions(
"int main() { clang^ }",
202 {
ns(
"clangA"), withReferences(NumReferences,
func(
"clangD"))},
205 ElementsAre(named(
"clangD"), named(
"clangA")));
207 completions(
"int main() { clang^ }",
208 {withReferences(NumReferences,
ns(
"clangA")),
func(
"clangD")},
211 ElementsAre(named(
"clangA"), named(
"clangD")));
215TEST(DecisionForestRankingModel, DecisionForestScorerCallbackTest) {
216 clangd::CodeCompleteOptions Opts;
217 constexpr float MagicNumber = 1234.5678f;
218 Opts.RankingModel = CodeCompleteOptions::DecisionForest;
222 Scores.
Total = MagicNumber;
223 Scores.ExcludingName = MagicNumber;
226 llvm::StringRef Code =
"int func() { int xyz; xy^ }";
227 auto Results = completions(Code,
229 ASSERT_EQ(Results.Completions.size(), 1u);
230 EXPECT_EQ(Results.Completions[0].Score.Total, MagicNumber);
231 EXPECT_EQ(Results.Completions[0].Score.ExcludingName, MagicNumber);
234 Opts.RankingModel = CodeCompleteOptions::Heuristics;
235 Results = completions(Code,
237 ASSERT_EQ(Results.Completions.size(), 1u);
238 EXPECT_NE(Results.Completions[0].Score.Total, MagicNumber);
239 EXPECT_NE(Results.Completions[0].Score.ExcludingName, MagicNumber);
242TEST(CompletionTest, Limit) {
243 clangd::CodeCompleteOptions Opts;
245 auto Results = completions(R
"cpp(
246struct ClassWithMembers {
252int main() { ClassWithMembers().^ }
256 EXPECT_TRUE(Results.HasMore);
257 EXPECT_THAT(Results.Completions, ElementsAre(named(
"AAA"), named(
"BBB")));
260TEST(CompletionTest, Filter) {
261 std::string Body = R
"cpp(
272 EXPECT_THAT(completions(Body +
"int main() { S().Foba^ }").Completions,
273 AllOf(has(
"FooBar"), has(
"FooBaz"), Not(has(
"Qux"))));
277 Sym.SymInfo.Kind = index::SymbolKind::Macro;
279 completions(Body +
"int main() { C^ }", {Sym}).Completions,
280 AllOf(has(
"Car"), Not(has(
"MotorCar")), Not(has(
"MotorCarIndex"))));
281 EXPECT_THAT(completions(Body +
"int main() { M^ }", {Sym}).Completions,
282 AllOf(has(
"MotorCar"), has(
"MotorCarIndex")));
285void testAfterDotCompletion(clangd::CodeCompleteOptions Opts) {
286 auto Results = completions(
292 // Make sure this is not in preamble.
295 struct GlobalClass {};
297 struct ClassWithMembers {
307 struct LocalClass {};
315 {
cls(
"IndexClass"),
var(
"index_var"),
func(
"index_func")}, Opts);
317 EXPECT_TRUE(Results.RanParser);
320 EXPECT_THAT(Results.Completions,
321 AllOf(has(
"method"), has(
"field"), Not(has(
"ClassWithMembers")),
322 Not(has(
"operator=")), Not(has(
"~ClassWithMembers"))));
323 EXPECT_IFF(Opts.IncludeIneligibleResults, Results.Completions,
324 has(
"private_field"));
328 Not(AnyOf(has(
"global_var"), has(
"index_var"), has(
"global_func"),
329 has(
"global_func()"), has(
"index_func"), has(
"GlobalClass"),
330 has(
"IndexClass"), has(
"MACRO"), has(
"LocalClass"))));
333 EXPECT_THAT(Results.Completions,
336 EXPECT_THAT(Results.Completions, Contains(isDocumented()));
339void testGlobalScopeCompletion(clangd::CodeCompleteOptions Opts) {
340 auto Results = completions(
345 // Make sure this is not in preamble.
348 struct GlobalClass {};
350 struct ClassWithMembers {
356 struct LocalClass {};
364 {
cls(
"IndexClass"),
var(
"index_var"),
func(
"index_func")}, Opts);
366 EXPECT_TRUE(Results.RanParser);
368 EXPECT_THAT(Results.Completions,
369 Not(AnyOf(has(
"method"), has(
"method()"), has(
"field"))));
371 EXPECT_THAT(Results.Completions,
372 AllOf(has(
"global_var"), has(
"index_var"), has(
"global_func"),
374 has(
"GlobalClass"), has(
"IndexClass")));
376 EXPECT_THAT(Results.Completions, has(
"MACRO"));
378 EXPECT_THAT(Results.Completions,
379 AllOf(has(
"local_var"), has(
"LocalClass"),
382 EXPECT_THAT(Results.Completions, Contains(isDocumented()));
385TEST(CompletionTest, CompletionOptions) {
386 auto Test = [&](
const clangd::CodeCompleteOptions &Opts) {
387 testAfterDotCompletion(Opts);
388 testGlobalScopeCompletion(Opts);
392 &clangd::CodeCompleteOptions::IncludeIneligibleResults,
397 for (
auto &F : Flags) {
398 clangd::CodeCompleteOptions O;
404TEST(CompletionTest, Accessible) {
405 auto Internal = completions(R
"cpp(
408 protected: void prot();
409 private: void priv();
411 void Foo::pub() { this->^ }
413 EXPECT_THAT(Internal.Completions,
414 AllOf(has("priv"), has(
"prot"), has(
"pub")));
416 auto External = completions(R
"cpp(
419 protected: void prot();
420 private: void priv();
427 EXPECT_THAT(External.Completions,
428 AllOf(has("pub"), Not(has(
"prot")), Not(has(
"priv"))));
430 auto Results = completions(R
"cpp(
433 protected: void prot();
434 private: void priv();
436 struct Bar : public Foo {
437 private: using Foo::pub;
444 EXPECT_THAT(Results.Completions,
445 AllOf(Not(has("priv")), Not(has(
"prot")), Not(has(
"pub"))));
448TEST(CompletionTest, Qualifiers) {
449 auto Results = completions(R
"cpp(
451 public: int foo() const;
454 class Bar : public Foo {
457 void test() { Bar().^ }
459 EXPECT_THAT(Results.Completions,
460 Contains(AllOf(qualifier(""), named(
"bar"))));
462 EXPECT_THAT(Results.Completions,
463 Not(Contains(AllOf(qualifier(
"Foo::"), named(
"foo")))));
465 EXPECT_THAT(Results.Completions,
466 Not(Contains(AllOf(qualifier(
""), named(
"foo")))));
470TEST(CompletionTest, QualificationWithInlineNamespace) {
471 auto Results = completions(R
"cpp(
472 namespace a { inline namespace b {} }
473 using namespace a::b;
477 EXPECT_THAT(Results.Completions,
478 UnorderedElementsAre(AllOf(qualifier(
"a::"), named(
"Foo"))));
481TEST(CompletionTest, InjectedTypename) {
483 EXPECT_THAT(completions(
"struct X{}; void foo(){ X().^ }").Completions,
485 EXPECT_THAT(completions(
"struct X{ void foo(){ this->^ } };").Completions,
488 EXPECT_THAT(completions(
"struct X{ void foo(){ ^ } };").Completions,
491 completions(
"struct Y{}; struct X:Y{ void foo(){ ^ } };").Completions,
495 "template<class> struct Y{}; struct X:Y<int>{ void foo(){ ^ } };")
499 EXPECT_THAT(completions(
"struct X{}; void foo(){ X::^ }").Completions,
503TEST(CompletionTest, SkipInjectedWhenUnqualified) {
504 EXPECT_THAT(completions(
"struct X { void f() { X^ }};").Completions,
505 ElementsAre(named(
"X"), named(
"~X")));
508TEST(CompletionTest, Snippets) {
509 clangd::CodeCompleteOptions Opts;
510 auto Results = completions(
514 int f(int i, const float f) const;
525 snippetSuffix(
"(${1:int i}, ${2:const float f})")));
528TEST(CompletionTest, HeuristicsForMemberFunctionCompletion) {
529 clangd::CodeCompleteOptions Opts;
530 Opts.EnableSnippets =
true;
534 static int staticMethod(int);
535 int method(int) const;
536 template <typename T, typename U, typename V = int>
538 template <typename T, int U>
539 static T staticGeneric();
547 struct Derived : Foo {
560 ; // Prevent parsing as 'f.f'
566 d.Derived::$canBeCall^
574 ; // Prevent parsing as 'f.f'
580 d.Derived::$canBeCall^
585 for (
const auto &P : Code.points(
"canNotBeCall")) {
586 auto Results = completions(TU, P, {}, Opts);
587 EXPECT_THAT(Results.Completions,
588 Contains(AllOf(named(
"method"), signature(
"(int) const"),
589 snippetSuffix(
""))));
594 Contains(AllOf(named(
"generic"),
595 signature(
"<typename T, typename U>(U, V)"),
596 snippetSuffix(
"<${1:typename T}, ${2:typename U}>"))));
599 for (
const auto &P : Code.points(
"canBeCall")) {
600 auto Results = completions(TU, P, {}, Opts);
601 EXPECT_THAT(Results.Completions,
602 Contains(AllOf(named(
"method"), signature(
"(int) const"),
603 snippetSuffix(
"(${1:int})"))));
606 Contains(AllOf(named(
"generic"), signature(
"<typename T>(U, V)"),
607 snippetSuffix(
"<${1:typename T}>(${2:U}, ${3:V})"))));
611 for (
const auto &P : Code.points()) {
612 auto Results = completions(TU, P, {}, Opts);
613 EXPECT_THAT(Results.Completions,
614 Contains(AllOf(named(
"staticMethod"), signature(
"(int)"),
615 snippetSuffix(
"(${1:int})"))));
616 EXPECT_THAT(Results.Completions,
618 named(
"staticGeneric"), signature(
"<typename T, int U>()"),
619 snippetSuffix(
"<${1:typename T}, ${2:int U}>()"))));
623TEST(CompletionTest, NoSnippetsInUsings) {
624 clangd::CodeCompleteOptions Opts;
625 Opts.EnableSnippets =
true;
626 auto Results = completions(
629 int func(int a, int b);
635 EXPECT_THAT(Results.Completions,
636 ElementsAre(AllOf(named(
"func"), labeled(
"func(int a, int b)"),
637 snippetSuffix(
""))));
640 auto Func =
func(
"ns::func");
641 Func.CompletionSnippetSuffix =
"(${1:int a}, ${2: int b})";
642 Func.Signature =
"(int a, int b)";
643 Func.ReturnType =
"void";
645 Results = completions(R
"cpp(
650 EXPECT_THAT(Results.Completions,
651 ElementsAre(AllOf(named(
"func"), labeled(
"func(int a, int b)"),
652 snippetSuffix(
""))));
655 Opts.AllScopes =
true;
656 Results = completions(R
"cpp(
660 EXPECT_THAT(Results.Completions,
661 Contains(AllOf(named(
"func"), labeled(
"ns::func(int a, int b)"),
662 snippetSuffix(
""))));
665TEST(CompletionTest, Kinds) {
666 auto Results = completions(
671 // make sure MACRO is not included in preamble.
675 {func("indexFunction"),
var(
"indexVariable"),
cls(
"indexClass"),
676 macro(
"indexObjMacro"),
macro(
"indexFuncMacro",
"(x, y)")});
677 EXPECT_THAT(Results.Completions,
689 Results = completions(
"nam^");
690 EXPECT_THAT(Results.Completions,
694 Results = completions(
708 Results = completions(
710 template <class T> struct complete_class {};
711 template <class T> void complete_function();
712 template <class T> using complete_type_alias = int;
713 template <class T> int complete_variable = 10;
716 template <class T> static int complete_static_member = 10;
718 static auto x = complete_^
723 UnorderedElementsAre(
726 AllOf(named(
"complete_type_alias"),
729 AllOf(named(
"complete_static_member"),
732 Results = completions(
744TEST(CompletionTest, NoDuplicates) {
745 auto Results = completions(
757 EXPECT_THAT(Results.Completions, ElementsAre(named(
"Adapter")));
760TEST(CompletionTest, ScopedNoIndex) {
761 auto Results = completions(
763 namespace fake { int BigBang, Babble, Box; };
764 int main() { fake::ba^ }
767 EXPECT_THAT(Results.Completions,
768 ElementsAre(named(
"Babble"), named(
"BigBang")));
771TEST(CompletionTest, Scoped) {
772 auto Results = completions(
774 namespace fake { int Babble, Box; };
775 int main() { fake::ba^ }
777 {var("fake::BigBang")});
778 EXPECT_THAT(Results.Completions,
779 ElementsAre(named(
"Babble"), named(
"BigBang")));
782TEST(CompletionTest, ScopedWithFilter) {
783 auto Results = completions(
787 {cls("ns::XYZ"),
func(
"ns::foo")});
788 EXPECT_THAT(Results.Completions, UnorderedElementsAre(named(
"XYZ")));
791TEST(CompletionTest, ReferencesAffectRanking) {
792 EXPECT_THAT(completions(
"int main() { abs^ }", {
func(
"absA"),
func(
"absB")})
795 EXPECT_THAT(completions(
"int main() { abs^ }",
796 {
func(
"absA"), withReferences(1000,
func(
"absB"))})
801TEST(CompletionTest, ContextWords) {
802 auto Results = completions(R
"cpp(
803 enum class Color { RED, YELLOW, BLUE };
805 // (blank lines so the definition above isn't "context")
807 // "It was a yellow car," he said. "Big yellow car, new."
808 auto Finish = Color::^
812 ASSERT_THAT(Results.Completions,
816TEST(CompletionTest, GlobalQualified) {
817 auto Results = completions(
822 EXPECT_THAT(Results.Completions,
827TEST(CompletionTest, FullyQualified) {
828 auto Results = completions(
830 namespace ns { void bar(); }
834 EXPECT_THAT(Results.Completions,
839TEST(CompletionTest, SemaIndexMerge) {
840 auto Results = completions(
842 namespace ns { int local; void both(); }
845 {func("ns::both"),
cls(
"ns::Index")});
847 EXPECT_THAT(Results.Completions,
848 UnorderedElementsAre(
855TEST(CompletionTest, SemaIndexMergeWithLimit) {
856 clangd::CodeCompleteOptions Opts;
858 auto Results = completions(
860 namespace ns { int local; void both(); }
863 {func("ns::both"),
cls(
"ns::Index")}, Opts);
864 EXPECT_EQ(Results.Completions.size(), Opts.Limit);
865 EXPECT_TRUE(Results.HasMore);
868TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
871 TU.AdditionalFiles[
"sub/bar.h"] =
"";
875 Sym.CanonicalDeclaration.FileURI = BarURI.c_str();
879 TU.Code = Test.code().str();
880 auto Results = completions(TU, Test.point(), {Sym});
881 EXPECT_THAT(Results.Completions,
882 ElementsAre(AllOf(named(
"X"), insertInclude(
"\"bar.h\""))));
886 Results = completions(TU, Test.point(), {Sym}, NoInsertion);
887 EXPECT_THAT(Results.Completions,
888 ElementsAre(AllOf(named(
"X"), Not(insertInclude()))));
891 #include "sub/bar.h" // not shortest, so should only match resolved.
894 TU.Code = Test.code().str();
895 Results = completions(TU, Test.point(), {Sym});
896 EXPECT_THAT(Results.Completions, ElementsAre(AllOf(named("X"), labeled(
"X"),
897 Not(insertInclude()))));
900TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
903 std::string BarHeader =
testPath(
"bar.h");
905 SymX.CanonicalDeclaration.FileURI = BarURI.c_str();
906 SymY.CanonicalDeclaration.FileURI = BarURI.c_str();
910 auto Results = completions(R
"cpp(
918 EXPECT_THAT(Results.Completions,
919 ElementsAre(AllOf(named("X"), Not(insertInclude())),
920 AllOf(named(
"Y"), Not(insertInclude()))));
923TEST(CompletionTest, IncludeInsertionRespectsQuotedAngledConfig) {
926 TU.AdditionalFiles[
"sub/bar.h"] =
"";
930 Sym.CanonicalDeclaration.FileURI = BarURI.c_str();
933 TU.Code = Test.code().str();
934 auto Results = completions(TU, Test.point(), {Sym});
936 EXPECT_THAT(Results.Completions,
937 ElementsAre(AllOf(named(
"X"), insertInclude(
"\"bar.h\""))));
940 C.Style.AngledHeaders.push_back(
941 [](
auto header) {
return header.contains(
"bar.h"); });
943 Results = completions(TU, Test.point(), {Sym});
944 EXPECT_THAT(Results.Completions,
945 ElementsAre(AllOf(named(
"X"), insertInclude(
"<bar.h>"))));
949 C.Style.QuotedHeaders.push_back(
950 [](
auto header) {
return header.contains(
"bar.h"); });
952 Results = completions(TU, Test.point(), {Sym});
953 EXPECT_THAT(Results.Completions,
954 ElementsAre(AllOf(named(
"X"), insertInclude(
"\"bar.h\""))));
958TEST(CompletionTest, IndexSuppressesPreambleCompletions) {
961 namespace ns { int local; }
963 void f2() { ns::preamble().$2^; }
966 TU.AdditionalFiles[
"bar.h"] =
967 R
"cpp(namespace ns { struct preamble { int member; }; })cpp";
969 clangd::CodeCompleteOptions Opts = {};
970 auto I = memIndex({
var(
"ns::index")});
971 Opts.Index = I.get();
972 auto WithIndex = completions(TU, Test.point(), {}, Opts);
973 EXPECT_THAT(WithIndex.Completions,
974 UnorderedElementsAre(named(
"local"), named(
"index")));
975 auto ClassFromPreamble = completions(TU, Test.point(
"2"), {}, Opts);
976 EXPECT_THAT(ClassFromPreamble.Completions, Contains(named(
"member")));
978 Opts.Index =
nullptr;
979 auto WithoutIndex = completions(TU, Test.point(), {}, Opts);
980 EXPECT_THAT(WithoutIndex.Completions,
981 UnorderedElementsAre(named(
"local"), named(
"preamble")));
988TEST(CompletionTest, CompletionInPreamble) {
989 auto Results = completions(R
"cpp(
997 EXPECT_THAT(Results, ElementsAre(named("ifndef")));
1000TEST(CompletionTest, CompletionRecoveryASTType) {
1001 auto Results = completions(R
"cpp(
1002 struct S { int member; };
1005 // No overload matches, but we have recovery-expr with the correct type.
1009 EXPECT_THAT(Results, ElementsAre(named("member")));
1012TEST(CompletionTest, DynamicIndexIncludeInsertion) {
1016 Opts.BuildDynamicSymbolIndex =
true;
1019 FS.Files[
testPath(
"foo_header.h")] = R
"cpp(
1026 const std::string FileContent(R
"cpp(
1027 #include "foo_header.h"
1032 Server.addDocument(testPath("foo_impl.cpp"), FileContent);
1034 ASSERT_TRUE(Server.blockUntilIdleForTest());
1043 ElementsAre(AllOf(named(
"Foo"), hasInclude(
"\"foo_header.h\""),
1047TEST(CompletionTest, DynamicIndexMultiFile) {
1051 Opts.BuildDynamicSymbolIndex =
true;
1054 FS.Files[
testPath(
"foo.h")] = R
"cpp(
1055 namespace ns { class XYZ {}; void foo(int x) {} }
1078 EXPECT_THAT(Results.Completions,
1080 doc(
"Doooc"), returnType(
"void"))));
1083TEST(CompletionTest, Documentation) {
1084 auto Results = completions(
1086 // Non-doxygen comment.
1087 __attribute__((annotate("custom_annotation"))) int foo();
1099 Results.Completions,
1102 doc(
"Annotation: custom_annotation\n\nNon-doxygen comment."))));
1104 Results.Completions,
1105 Contains(AllOf(named(
"bar"), doc(
"Doxygen comment.\n\\param int a"))));
1106 EXPECT_THAT(Results.Completions,
1107 Contains(AllOf(named(
"baz"), doc(
"Multi-line block comment"))));
1110TEST(CompletionTest, CommentsFromSystemHeaders) {
1115 Opts.BuildDynamicSymbolIndex =
true;
1119 FS.Files[
testPath(
"foo.h")] = R
"cpp(
1120 #pragma GCC system_header
1122 // This comment should be retained!
1137 Contains(AllOf(named(
"foo"), doc(
"This comment should be retained!"))));
1140TEST(CompletionTest, CommentsOnMembersFromHeader) {
1145 Opts.BuildDynamicSymbolIndex =
true;
1149 FS.Files[
testPath(
"foo.h")] = R
"cpp(
1170 Contains(AllOf(named(
"gamma"), doc(
"This is a member field."))));
1173 Contains(AllOf(named(
"delta"), doc(
"This is a member function."))));
1176TEST(CompletionTest, CommentsOnMembersFromHeaderOverloadBundling) {
1177 using testing::AnyOf;
1182 Opts.BuildDynamicSymbolIndex =
true;
1186 FS.Files[
testPath(
"foo.h")] = R
"cpp(
1194 void epsilon(long l);
1197 void epsilon(int i);
1208 clangd::CodeCompleteOptions CCOpts;
1209 CCOpts.BundleOverloads = true;
1215 Contains(AllOf(named(
"epsilon"), doc(
"This one has a comment."))));
1217 Contains(AllOf(named(
"delta"), AnyOf(doc(
"bool overload."),
1218 doc(
"int overload.")))));
1221TEST(CompletionTest, GlobalCompletionFiltering) {
1230 auto Results = completions(R
"(// void f() {
1234 EXPECT_THAT(Results.Completions, IsEmpty());
1237TEST(CodeCompleteTest, DisableTypoCorrection) {
1238 auto Results = completions(R
"cpp(
1239 namespace clang { int v; }
1240 void f() { clangd::^
1242 EXPECT_TRUE(Results.Completions.empty());
1245TEST(CodeCompleteTest, NoColonColonAtTheEnd) {
1246 auto Results = completions(R
"cpp(
1253 EXPECT_THAT(Results.Completions, Contains(labeled("clang")));
1254 EXPECT_THAT(Results.Completions, Not(Contains(labeled(
"clang::"))));
1257TEST(CompletionTests, EmptySnippetDoesNotCrash) {
1259 auto Results = completions(R
"cpp(
1261 auto w = [&](auto &&f) { return f(f); };
1262 auto f = w([&](auto &&f) {
1263 return [&](auto &&n) {
1267 return n * ^(f)(n - 1);
1274TEST(CompletionTest, Issue1427Crash) {
1280 Opts.MainFileSignals = &MainFileSignals;
1289TEST(CompletionTest, BacktrackCrashes) {
1291 auto Results = completions(R
"cpp(
1293 struct FooBarBaz {};
1299 EXPECT_THAT(Results.Completions, ElementsAre(labeled("FooBarBaz")));
1303 struct FooBarBaz {};
1305 if (FooBarBaz * x^) {}
1310TEST(CompletionTest, CompleteInMacroWithStringification) {
1311 auto Results = completions(R
"cpp(
1312void f(const char *, int x);
1313#define F(x) f(#x, x)
1320int f(int input_num) {
1325 EXPECT_THAT(Results.Completions,
1326 UnorderedElementsAre(named("X"), named(
"Y")));
1329TEST(CompletionTest, CompleteInMacroAndNamespaceWithStringification) {
1330 auto Results = completions(R
"cpp(
1331void f(const char *, int x);
1332#define F(x) f(#x, x)
1337int f(int input_num) {
1343 EXPECT_THAT(Results.Completions, Contains(named("X")));
1346TEST(CompletionTest, IgnoreCompleteInExcludedPPBranchWithRecoveryContext) {
1347 auto Results = completions(R
"cpp(
1348 int bar(int param_in_bar) {
1351 int foo(int param_in_foo) {
1353 // In recovery mode, "param_in_foo" will also be suggested among many other
1354 // unrelated symbols; however, this is really a special case where this works.
1355 // If the #if block is outside of the function, "param_in_foo" is still
1356 // suggested, but "bar" and "foo" are missing. So the recovery mode doesn't
1357 // really provide useful results in excluded branches.
1363 EXPECT_TRUE(Results.Completions.empty());
1366TEST(CompletionTest, DefaultArgs) {
1367 clangd::CodeCompleteOptions Opts;
1370 int Y(int A, int B = 0);
1371 int Z(int A, int B = 0, int C = 0, int D = 0);
1373 EXPECT_THAT(completions(Context + "int y = X^", {}, Opts).Completions,
1374 UnorderedElementsAre(labeled(
"X(int A = 0)")));
1375 EXPECT_THAT(completions(
Context +
"int y = Y^", {}, Opts).Completions,
1376 UnorderedElementsAre(AllOf(labeled(
"Y(int A, int B = 0)"),
1377 snippetSuffix(
"(${1:int A})"))));
1378 EXPECT_THAT(completions(
Context +
"int y = Z^", {}, Opts).Completions,
1379 UnorderedElementsAre(
1380 AllOf(labeled(
"Z(int A, int B = 0, int C = 0, int D = 0)"),
1381 snippetSuffix(
"(${1:int A})"))));
1384TEST(CompletionTest, NoCrashWithTemplateParamsAndPreferredTypes) {
1385 auto Completions = completions(R
"cpp(
1386template <template <class> class TT> int foo() {
1391 EXPECT_THAT(Completions, Contains(named("TT")));
1394TEST(CompletionTest, NestedTemplateHeuristics) {
1395 auto Completions = completions(R
"cpp(
1396struct Plain { int xxx; };
1397template <typename T> class Templ { Plain ppp; };
1398template <typename T> void foo(Templ<T> &t) {
1399 // Formally ppp has DependentTy, because Templ may be specialized.
1400 // However we sholud be able to see into it using the primary template.
1405 EXPECT_THAT(Completions, Contains(named("xxx")));
1408TEST(CompletionTest, RecordCCResultCallback) {
1409 std::vector<CodeCompletion> RecordedCompletions;
1411 Opts.RecordCCResult = [&RecordedCompletions](
const CodeCompletion &CC,
1415 RecordedCompletions.push_back(CC);
1418 completions(
"int xy1, xy2; int a = xy^", {}, Opts);
1419 EXPECT_THAT(RecordedCompletions,
1420 UnorderedElementsAre(named(
"xy1"), named(
"xy2")));
1426 unsigned MainFileRefs;
1427 unsigned ScopeRefsInFile;
1430 std::vector<Completion> RecordedCompletions;
1431 Opts.RecordCCResult = [&RecordedCompletions](
const CodeCompletion &CC,
1435 RecordedCompletions.push_back({CC.Name, R.MainFileRefs, R.ScopeRefsInFile});
1439 MainFileSignals.ReferencedSymbols[
var(
"xy2").
ID] = 1;
1440 MainFileSignals.ReferencedSymbols[
var(
"xyindex").
ID] = 10;
1441 MainFileSignals.RelatedNamespaces[
"tar::"] = 5;
1442 MainFileSignals.RelatedNamespaces[
"bar::"] = 3;
1443 Opts.MainFileSignals = &MainFileSignals;
1444 Opts.AllScopes =
true;
1454 {
var(
"xyindex"),
var(
"tar::xytar"),
var(
"bar::xybar")},
1456 EXPECT_THAT(RecordedCompletions,
1457 UnorderedElementsAre(
1458 AllOf(named(
"xy1"), mainFileRefs(3u), scopeRefs(0u)),
1459 AllOf(named(
"xy2"), mainFileRefs(1u), scopeRefs(0u)),
1460 AllOf(named(
"xyindex"), mainFileRefs(10u), scopeRefs(0u)),
1461 AllOf(named(
"xytar"), mainFileRefs(0u), scopeRefs(5u)),
1462 AllOf( named(
"xybar"),
1463 mainFileRefs(0u), scopeRefs(3u))));
1468 std::vector<Symbol> IndexSymbols = {},
1470 std::unique_ptr<SymbolIndex> Index;
1471 if (!IndexSymbols.empty())
1472 Index = memIndex(IndexSymbols);
1476 auto Inputs = TU.inputs(FS);
1477 Inputs.Index = Index.get();
1481 ADD_FAILURE() <<
"Couldn't build CompilerInvocation";
1487 ADD_FAILURE() <<
"Couldn't build Preamble";
1491 DocumentationFormat);
1495signatures(llvm::StringRef
Text, std::vector<Symbol> IndexSymbols = {},
1498 return signatures(Test.code(), Test.point(), std::move(IndexSymbols),
1499 DocumentationFormat);
1502struct ExpectedParameter {
1504 std::pair<unsigned, unsigned> Offsets;
1506llvm::raw_ostream &
operator<<(llvm::raw_ostream &OS,
1507 const ExpectedParameter &P) {
1508 return OS <<
P.Text;
1511 if (
P.size() != arg.parameters.size())
1513 for (
unsigned I = 0; I <
P.size(); ++I) {
1514 if (P[I].
Text != arg.parameters[I].labelString ||
1515 P[I].Offsets != arg.parameters[I].labelOffsets)
1520MATCHER_P(sigDoc, doc,
"") {
return arg.documentation.value == doc; }
1524Matcher<SignatureInformation> sig(llvm::StringRef AnnotatedLabel) {
1525 llvm::Annotations
A(AnnotatedLabel);
1526 std::string
Label = std::string(
A.code());
1527 std::vector<ExpectedParameter> Parameters;
1528 for (
auto Range :
A.ranges()) {
1529 Parameters.emplace_back();
1531 ExpectedParameter &
P = Parameters.back();
1536 return AllOf(sigHelpLabeled(
Label), paramsAre(Parameters));
1539TEST(SignatureHelpTest, Overloads) {
1540 auto Results = signatures(R
"cpp(
1541 void foo(int x, int y);
1542 void foo(int x, float y);
1543 void foo(float x, int y);
1544 void foo(float x, float y);
1545 void bar(int x, int y = 0);
1546 int main() { foo(^); }
1548 EXPECT_THAT(Results.signatures,
1549 UnorderedElementsAre(sig("foo([[float x]], [[float y]]) -> void"),
1550 sig(
"foo([[float x]], [[int y]]) -> void"),
1551 sig(
"foo([[int x]], [[float y]]) -> void"),
1552 sig(
"foo([[int x]], [[int y]]) -> void")));
1554 EXPECT_EQ(0, Results.activeSignature);
1555 EXPECT_EQ(0, Results.activeParameter);
1558TEST(SignatureHelpTest, FunctionPointers) {
1559 llvm::StringLiteral Tests[] = {
1562 void (*foo)(int x, int y);
1563 int main() { foo(^); }
1567 void (__stdcall *foo)(int x, int y);
1568 int main() { foo(^); }
1572 void (__attribute__(stdcall) *foo)(int x, int y);
1573 int main() { foo(^); },
1577 typedef void (*fn)(int x, int y);
1579 int main() { foo(^); }
1583 typedef void (__stdcall *fn)(int x, int y);
1585 int main() { foo(^); }
1590 void (*foo)(int x, int y);
1593 int main() { s.foo(^); }
1597 typedef void (*fn)(int x, int y);
1602 int main() { s.foo(^); }
1604 for (
auto Test : Tests)
1605 EXPECT_THAT(signatures(Test).signatures,
1606 UnorderedElementsAre(sig(
"([[int x]], [[int y]]) -> void")));
1609TEST(SignatureHelpTest, Constructors) {
1610 std::string Top = R
"cpp(
1613 S(const S &) = delete;
1617 auto CheckParenInit = [&](std::string Init) {
1618 EXPECT_THAT(signatures(Top + Init).signatures,
1619 UnorderedElementsAre(sig(
"S([[int]])")))
1622 CheckParenInit(
"S s(^);");
1623 CheckParenInit(
"auto s = S(^);");
1624 CheckParenInit(
"auto s = new S(^);");
1626 auto CheckBracedInit = [&](std::string Init) {
1627 EXPECT_THAT(signatures(Top + Init).signatures,
1628 UnorderedElementsAre(sig(
"S{[[int]]}")))
1631 CheckBracedInit(
"S s{^};");
1632 CheckBracedInit(
"S s = {^};");
1633 CheckBracedInit(
"auto s = S{^};");
1636 CheckBracedInit(
"int x(S); int i = x({^});");
1639TEST(SignatureHelpTest, Aggregates) {
1640 std::string Top = R
"cpp(
1645 auto AggregateSig = sig(
"S{[[int a]], [[int b]], [[int c]], [[int d]]}");
1646 EXPECT_THAT(signatures(Top +
"S s{^}").signatures,
1647 UnorderedElementsAre(AggregateSig, sig(
"S{}"),
1648 sig(
"S{[[const S &]]}"),
1649 sig(
"S{[[S &&]]}")));
1650 EXPECT_THAT(signatures(Top +
"S s{1,^}").signatures,
1651 ElementsAre(AggregateSig));
1652 EXPECT_EQ(signatures(Top +
"S s{1,^}").activeParameter, 1);
1653 EXPECT_THAT(signatures(Top +
"S s{.c=3,^}").signatures,
1654 ElementsAre(AggregateSig));
1655 EXPECT_EQ(signatures(Top +
"S s{.c=3,^}").activeParameter, 3);
1658TEST(SignatureHelpTest, OverloadInitListRegression) {
1659 auto Results = signatures(R
"cpp(
1668 EXPECT_THAT(Results.signatures, UnorderedElementsAre(sig("f() -> void")));
1671TEST(SignatureHelpTest, DefaultArgs) {
1672 auto Results = signatures(R
"cpp(
1673 void bar(int x, int y = 0);
1674 void bar(float x = 0, int y = 42);
1677 EXPECT_THAT(Results.signatures,
1678 UnorderedElementsAre(
1679 sig("bar([[int x]], [[int y = 0]]) -> void"),
1680 sig(
"bar([[float x = 0]], [[int y = 42]]) -> void")));
1681 EXPECT_EQ(0, Results.activeSignature);
1682 EXPECT_EQ(0, Results.activeParameter);
1685TEST(SignatureHelpTest, ActiveArg) {
1686 auto Results = signatures(R
"cpp(
1687 int baz(int a, int b, int c);
1688 int main() { baz(baz(1,2,3), ^); }
1690 EXPECT_THAT(Results.signatures,
1691 ElementsAre(sig("baz([[int a]], [[int b]], [[int c]]) -> int")));
1692 EXPECT_EQ(0, Results.activeSignature);
1693 EXPECT_EQ(1, Results.activeParameter);
1696TEST(SignatureHelpTest, OpeningParen) {
1697 llvm::StringLiteral Tests[] = {
1700 int foo(int a, int b, int c);
1702 foo(foo $p^( foo(10, 10, 10), ^ )));
1707 Foo(int a, int b, int c);
1715 Foo(int a, int b, int c);
1718 new Foo $p^( 10, ^ );
1722 int foo(int a, int b, int c);
1726 // Macro expansions.
1731 int foo(int a, int b, int c);
1734 // FIXME: figure out why ID(foo (foo(10), )) doesn't work when preserving
1735 // the recovery expression.
1736 ID(foo $p^( 10, ^ ))
1740 int foo(int a, int b);
1741 template <typename T> void bar(T t) {
1746 template <typename T>
1748 template <typename T> void bar(T t) {
1753 struct Foo { int foo(int, int); };
1754 template <typename T> void bar(T t) {
1760 struct Foo { template <typename T> int foo(T, T); };
1761 template <typename T> void bar(T t) {
1767 for (
auto Test : Tests) {
1769 EXPECT_EQ(signatures(Code.code(), Code.point()).argListStart,
1771 <<
"Test source:" << Test;
1775TEST(SignatureHelpTest, StalePreamble) {
1780 auto Inputs = TU.inputs(FS);
1785 ASSERT_TRUE(EmptyPreamble);
1787 TU.AdditionalFiles[
"a.h"] =
"int foo(int x);";
1790 void bar() { foo(^2); })cpp");
1791 TU.Code = Test.code().str();
1795 EXPECT_THAT(Results.signatures, ElementsAre(sig(
"foo([[int x]]) -> int")));
1796 EXPECT_EQ(0, Results.activeSignature);
1797 EXPECT_EQ(0, Results.activeParameter);
1802 IndexRequestCollector(std::vector<Symbol> Syms = {}) : Symbols(Syms) {}
1805 fuzzyFind(
const FuzzyFindRequest &Req,
1806 llvm::function_ref<
void(
const Symbol &)>
Callback)
const override {
1807 std::unique_lock<std::mutex> Lock(Mut);
1808 Requests.push_back(Req);
1809 ReceivedRequestCV.notify_one();
1810 for (
const auto &Sym : Symbols)
1815 void lookup(
const LookupRequest &,
1816 llvm::function_ref<
void(
const Symbol &)>)
const override {}
1818 bool refs(
const RefsRequest &,
1819 llvm::function_ref<
void(
const Ref &)>)
const override {
1824 const ContainedRefsRequest &,
1825 llvm::function_ref<
void(
const ContainedRefsResult &)>)
const override {
1829 void relations(
const RelationsRequest &,
1830 llvm::function_ref<
void(
const SymbolID &,
const Symbol &)>)
1834 indexedFiles()
const override {
1840 size_t estimateMemoryUsage()
const override {
return 0; }
1842 const std::vector<FuzzyFindRequest> consumeRequests(
size_t Num)
const {
1843 std::unique_lock<std::mutex> Lock(Mut);
1845 [
this, Num] {
return Requests.size() == Num; }));
1846 auto Reqs = std::move(Requests);
1852 std::vector<Symbol> Symbols;
1854 mutable std::condition_variable ReceivedRequestCV;
1855 mutable std::mutex Mut;
1856 mutable std::vector<FuzzyFindRequest> Requests;
1860std::vector<FuzzyFindRequest> captureIndexRequests(llvm::StringRef Code,
1862 clangd::CodeCompleteOptions Opts;
1863 IndexRequestCollector Requests;
1864 Opts.Index = &Requests;
1865 completions(Code, {}, Opts);
1866 const auto Reqs = Requests.consumeRequests(Num);
1867 EXPECT_EQ(Reqs.size(), Num);
1871TEST(CompletionTest, UnqualifiedIdQuery) {
1872 auto Requests = captureIndexRequests(R
"cpp(
1874 using namespace std;
1882 EXPECT_THAT(Requests,
1884 UnorderedElementsAre("",
"ns::",
"std::"))));
1887TEST(CompletionTest, EnclosingScopeComesFirst) {
1888 auto Requests = captureIndexRequests(R
"cpp(
1890 using namespace std;
1902 EXPECT_THAT(Requests,
1905 UnorderedElementsAre("",
"std::",
"nx::ns::",
"nx::"))));
1906 EXPECT_EQ(Requests[0].Scopes[0],
"nx::ns::");
1909TEST(CompletionTest, ResolvedQualifiedIdQuery) {
1910 auto Requests = captureIndexRequests(R
"cpp(
1912 namespace ns2 {} // ignore
1913 namespace ns3 { namespace nns3 {} }
1915 using namespace ns1;
1916 using namespace ns3::nns3;
1925 EXPECT_THAT(Requests,
1928 UnorderedElementsAre("foo::",
"ns1::",
"ns3::nns3::"))));
1931TEST(CompletionTest, UnresolvedQualifierIdQuery) {
1932 auto Requests = captureIndexRequests(R
"cpp(
1942 EXPECT_THAT(Requests,
1945 UnorderedElementsAre("a::bar::",
"ns::bar::",
"bar::"))));
1948TEST(CompletionTest, UnresolvedNestedQualifierIdQuery) {
1949 auto Requests = captureIndexRequests(R
"cpp(
1960 UnorderedElementsAre("a::bar::"))));
1963TEST(CompletionTest, EmptyQualifiedQuery) {
1964 auto Requests = captureIndexRequests(R
"cpp(
1973 UnorderedElementsAre("",
"ns::"))));
1976TEST(CompletionTest, GlobalQualifiedQuery) {
1977 auto Requests = captureIndexRequests(R
"cpp(
1986 UnorderedElementsAre(""))));
1989TEST(CompletionTest, NoDuplicatedQueryScopes) {
1990 auto Requests = captureIndexRequests(R
"cpp(
2001 EXPECT_THAT(Requests,
2003 UnorderedElementsAre("na::",
"na::nb::",
""))));
2006TEST(CompletionTest, NoIndexCompletionsInsideClasses) {
2007 auto Completions = completions(
2010 int SomeNameOfField;
2011 typedef int SomeNameOfTypedefField;
2015 {func("::SomeNameInTheIndex"),
func(
"::Foo::SomeNameInTheIndex")});
2017 EXPECT_THAT(Completions.Completions,
2018 AllOf(Contains(labeled(
"SomeNameOfField")),
2019 Contains(labeled(
"SomeNameOfTypedefField")),
2020 Not(Contains(labeled(
"SomeNameInTheIndex")))));
2023TEST(CompletionTest, NoIndexCompletionsInsideDependentCode) {
2025 auto Completions = completions(
2032 {func("::SomeNameInTheIndex")});
2034 EXPECT_THAT(Completions.Completions,
2035 Not(Contains(labeled(
"SomeNameInTheIndex"))));
2039 auto Completions = completions(
2043 T::template Y<int>::^
2046 {func("::SomeNameInTheIndex")});
2048 EXPECT_THAT(Completions.Completions,
2049 Not(Contains(labeled(
"SomeNameInTheIndex"))));
2053 auto Completions = completions(
2060 {func("::SomeNameInTheIndex")});
2062 EXPECT_THAT(Completions.Completions,
2063 Not(Contains(labeled(
"SomeNameInTheIndex"))));
2067TEST(CompletionTest, OverloadBundling) {
2068 clangd::CodeCompleteOptions Opts;
2069 Opts.BundleOverloads =
true;
2073 // Overload with int
2074 int a(int) __attribute__((deprecated("", "")));
2075 // Overload with bool
2087 EXPECT_THAT(completions(
Context +
"int y = X().^", {}, Opts).Completions,
2088 UnorderedElementsAre(labeled(
"a(…)"), labeled(
"b(float)")));
2091 EXPECT_THAT(completions(
Context +
"X z = X^", {}, Opts).Completions,
2092 UnorderedElementsAre(labeled(
"X"), labeled(
"X(…)")));
2097 completions(
Context +
"int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
2098 UnorderedElementsAre(labeled(
"GFuncC(…)"), labeled(
"GFuncD(int)")));
2102 NoArgsGFunc.CanonicalDeclaration.FileURI = DeclFile.c_str();
2105 completions(
Context +
"int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
2106 UnorderedElementsAre(AllOf(named(
"GFuncC"), insertInclude(
"<foo>")),
2107 labeled(
"GFuncC(int)"), labeled(
"GFuncD(int)")));
2111 completions(
Context +
"int y = X().a^", {}, Opts).Completions.front();
2112 EXPECT_EQ(
A.Name,
"a");
2113 EXPECT_EQ(
A.Signature,
"(…)");
2114 EXPECT_EQ(
A.BundleSize, 2u);
2116 EXPECT_EQ(
A.ReturnType,
"int");
2118 ASSERT_TRUE(
A.Documentation);
2119 ASSERT_FALSE(
A.Deprecated);
2121 A.Documentation->asPlainText(),
2122 AnyOf(HasSubstr(
"Overload with int"), HasSubstr(
"Overload with bool")));
2123 EXPECT_EQ(
A.SnippetSuffix,
"($0)");
2126TEST(CompletionTest, OverloadBundlingSameFileDifferentURI) {
2127 clangd::CodeCompleteOptions Opts;
2128 Opts.BundleOverloads =
true;
2130 Symbol SymX =
sym(
"ns::X", index::SymbolKind::Function,
"@F@\\0#");
2131 Symbol SymY =
sym(
"ns::X", index::SymbolKind::Function,
"@F@\\0#I#");
2132 std::string BarHeader =
testPath(
"bar.h");
2134 SymX.CanonicalDeclaration.FileURI = BarURI.c_str();
2135 SymY.CanonicalDeclaration.FileURI = BarURI.c_str();
2140 auto Results = completions(
"void f() { ::ns::^ }", {SymX, SymY}, Opts);
2143 ASSERT_EQ(1u, Results.Completions.size());
2144 const auto &R = Results.Completions.front();
2145 EXPECT_EQ(
"X", R.Name);
2146 EXPECT_EQ(2u, R.BundleSize);
2149TEST(CompletionTest, DocumentationFromChangedFileCrash) {
2153 FS.Files[FooH] = R
"cpp(
2154 // this is my documentation comment.
2157 FS.Files[FooCpp] = "";
2165 // This makes sure we have func from header in the AST.
2171 ASSERT_TRUE(Server.blockUntilIdleForTest());
2174 FS.Files[FooH] = R
"cpp(
2178 clangd::CodeCompleteOptions Opts;
2179 CodeCompleteResult Completions =
2183 EXPECT_THAT(Completions.Completions,
2184 Contains(AllOf(Not(isDocumented()), named(
"func"))));
2187TEST(CompletionTest, NonDocComments) {
2188 const char *
Text = R
"cpp(
2189 // We ignore namespace comments, for rationale see CodeCompletionStrings.h.
2190 namespace comments_ns {
2193 // ------------------
2196 // A comment and a decl are separated by newlines.
2197 // Therefore, the comment shouldn't show up as doc comment.
2201 // this comment should be in the results.
2208 int comments_quux();
2212 // This comment should not be there.
2215 int Struct<T>::comments_qux() {
2218 // This comment **should** be in results.
2220 int Struct<T>::comments_quux() {
2227 completions(
Text).Completions,
2228 UnorderedElementsAre(AllOf(Not(isDocumented()), named(
"comments_foo")),
2229 AllOf(isDocumented(), named(
"comments_baz")),
2230 AllOf(isDocumented(), named(
"comments_quux")),
2231 AllOf(Not(isDocumented()), named(
"comments_ns")),
2236 AllOf(isDocumented(), named(
"comments_bar")),
2237 AllOf(isDocumented(), named(
"comments_qux"))));
2240TEST(CompletionTest, CompleteOnInvalidLine) {
2245 FS.
Files[FooCpp] =
"// empty file";
2252 EXPECT_THAT_EXPECTED(
2257TEST(CompletionTest, QualifiedNames) {
2258 auto Results = completions(
2260 namespace ns { int local; void both(); }
2261 void f() { ::ns::^ }
2263 {func("ns::both"),
cls(
"ns::Index")});
2266 Results.Completions,
2267 UnorderedElementsAre(scope(
"ns::"), scope(
"ns::"), scope(
"ns::")));
2270TEST(CompletionTest, Render) {
2274 C.Signature =
"(bool) const";
2275 C.SnippetSuffix =
"(${0:bool})";
2276 C.ReturnType =
"int";
2277 C.RequiredQualifier =
"Foo::";
2278 C.Scope =
"ns::Foo::";
2279 C.Documentation.emplace();
2280 C.Documentation->addParagraph().appendText(
"This is ").appendCode(
"x()");
2281 C.Includes.emplace_back();
2282 auto &Include =
C.Includes.back();
2283 Include.Header =
"\"foo.h\"";
2285 C.Score.Total = 1.0;
2286 C.Score.ExcludingName = .5;
2290 Opts.IncludeIndicator.Insert =
"^";
2291 Opts.IncludeIndicator.NoInsert =
"";
2292 Opts.EnableSnippets =
false;
2294 auto R =
C.render(Opts);
2295 EXPECT_EQ(R.label,
"Foo::x");
2296 EXPECT_EQ(R.labelDetails->detail,
"(bool) const");
2297 EXPECT_EQ(R.insertText,
"Foo::x");
2299 EXPECT_EQ(R.filterText,
"x");
2300 EXPECT_EQ(R.detail,
"int");
2301 EXPECT_EQ(R.documentation->value,
"From \"foo.h\"\n\nThis is x()");
2302 EXPECT_THAT(R.additionalTextEdits, IsEmpty());
2303 EXPECT_EQ(R.sortText,
sortText(1.0,
"x"));
2304 EXPECT_FALSE(R.deprecated);
2305 EXPECT_EQ(R.score, .5f);
2307 C.FilterText =
"xtra";
2309 EXPECT_EQ(R.filterText,
"xtra");
2310 EXPECT_EQ(R.sortText,
sortText(1.0,
"xtra"));
2312 Opts.EnableSnippets =
true;
2314 EXPECT_EQ(R.insertText,
"Foo::x(${0:bool})");
2317 C.SnippetSuffix =
"";
2319 EXPECT_EQ(R.insertText,
"Foo::x");
2322 Include.Insertion.emplace();
2324 EXPECT_EQ(R.label,
"^Foo::x");
2325 EXPECT_EQ(R.labelDetails->detail,
"(bool) const");
2326 EXPECT_THAT(R.additionalTextEdits, Not(IsEmpty()));
2328 Opts.ShowOrigins =
true;
2330 EXPECT_EQ(R.label,
"^[AS]Foo::x");
2331 EXPECT_EQ(R.labelDetails->detail,
"(bool) const");
2335 EXPECT_EQ(R.detail,
"[2 overloads]");
2336 EXPECT_EQ(R.documentation->value,
"From \"foo.h\"\n\nThis is x()");
2338 C.Deprecated =
true;
2340 EXPECT_TRUE(R.deprecated);
2344 EXPECT_EQ(R.documentation->value,
"From `\"foo.h\"`\n\nThis is `x()`");
2347TEST(CompletionTest, IgnoreRecoveryResults) {
2348 auto Results = completions(
2350 namespace ns { int NotRecovered() { return 0; } }
2352 // Sema enters recovery mode first and then normal mode.
2353 if (auto x = ns::NotRecover^)
2356 EXPECT_THAT(Results.Completions, UnorderedElementsAre(named("NotRecovered")));
2359TEST(CompletionTest, ScopeOfClassFieldInConstructorInitializer) {
2360 auto Results = completions(
2363 class X { public: X(); int x_; };
2367 EXPECT_THAT(Results.Completions,
2368 UnorderedElementsAre(AllOf(scope("ns::X::"), named(
"x_"))));
2375TEST(CompletionTest, ConstructorInitListIncomplete) {
2376 auto Results = completions(
2385 EXPECT_THAT(Results.Completions, ElementsAre(named("xyz_")));
2387 Results = completions(
2398 EXPECT_THAT(Results.Completions, ElementsAre(named("foo")));
2401TEST(CompletionTest, CodeCompletionContext) {
2402 auto Results = completions(
2405 class X { public: X(); int x_; };
2413 EXPECT_THAT(Results.Context, CodeCompletionContext::CCC_DotMemberAccess);
2416TEST(CompletionTest, FixItForArrowToDot) {
2421 Opts.IncludeFixIts = true;
2428 class ClassWithPtr {
2430 void MemberFunction();
2431 Auxilary* operator->() const;
2439 auto Results = completions(Code, {}, Opts);
2440 EXPECT_EQ(Results.Completions.size(), 3u);
2444 ReplacementEdit.newText =
".";
2445 for (
const auto &C : Results.Completions) {
2446 EXPECT_TRUE(
C.FixIts.size() == 1u ||
C.Name ==
"AuxFunction");
2447 if (!
C.FixIts.empty()) {
2448 EXPECT_THAT(
C.FixIts, ElementsAre(ReplacementEdit));
2453TEST(CompletionTest, FixItForDotToArrow) {
2455 Opts.IncludeFixIts =
true;
2462 class ClassWithPtr {
2464 void MemberFunction();
2465 Auxilary* operator->() const;
2473 auto Results = completions(Code, {}, Opts);
2474 EXPECT_EQ(Results.Completions.size(), 3u);
2478 ReplacementEdit.newText =
"->";
2479 for (
const auto &C : Results.Completions) {
2480 EXPECT_TRUE(
C.FixIts.empty() ||
C.Name ==
"AuxFunction");
2481 if (!
C.FixIts.empty()) {
2482 EXPECT_THAT(
C.FixIts, ElementsAre(ReplacementEdit));
2487TEST(CompletionTest, RenderWithFixItMerged) {
2490 FixIt.newText =
"->";
2494 C.RequiredQualifier =
"Foo::";
2496 C.CompletionTokenRange.start.character = 5;
2499 Opts.IncludeFixIts =
true;
2501 auto R =
C.render(Opts);
2502 EXPECT_TRUE(R.textEdit);
2503 EXPECT_EQ(R.textEdit->newText,
"->Foo::x");
2504 EXPECT_TRUE(R.additionalTextEdits.empty());
2507TEST(CompletionTest, RenderWithFixItNonMerged) {
2510 FixIt.newText =
"->";
2514 C.RequiredQualifier =
"Foo::";
2516 C.CompletionTokenRange.start.character = 5;
2519 Opts.IncludeFixIts =
true;
2521 auto R =
C.render(Opts);
2522 EXPECT_TRUE(R.textEdit);
2523 EXPECT_EQ(R.textEdit->newText,
"Foo::x");
2524 EXPECT_THAT(R.additionalTextEdits, UnorderedElementsAre(FixIt));
2527TEST(CompletionTest, CompletionTokenRange) {
2533 constexpr const char *TestCodes[] = {
2555 #include "foo/[[a^/]]foo.h"
2558 #include "foo/abc/[[fo^o.h"]]
2561 for (
const auto &
Text : TestCodes) {
2563 TU.Code = TestCode.code().str();
2564 auto Results = completions(TU, TestCode.point());
2565 if (Results.Completions.size() != 1) {
2566 ADD_FAILURE() <<
"Results.Completions.size() != 1" <<
Text;
2569 EXPECT_THAT(Results.Completions.front().CompletionTokenRange,
2574TEST(SignatureHelpTest, OverloadsOrdering) {
2575 const auto Results = signatures(R
"cpp(
2577 void foo(int x, float y);
2578 void foo(float x, int y);
2579 void foo(float x, float y);
2580 void foo(int x, int y = 0);
2581 int main() { foo(^); }
2583 EXPECT_THAT(Results.signatures,
2584 ElementsAre(sig("foo([[int x]]) -> void"),
2585 sig(
"foo([[int x]], [[int y = 0]]) -> void"),
2586 sig(
"foo([[float x]], [[int y]]) -> void"),
2587 sig(
"foo([[int x]], [[float y]]) -> void"),
2588 sig(
"foo([[float x]], [[float y]]) -> void")));
2590 EXPECT_EQ(0, Results.activeSignature);
2591 EXPECT_EQ(0, Results.activeParameter);
2594TEST(SignatureHelpTest, InstantiatedSignatures) {
2595 StringRef Sig0 = R
"cpp(
2604 EXPECT_THAT(signatures(Sig0).signatures,
2605 ElementsAre(sig("foo([[T]], [[T]], [[T]]) -> void")));
2607 StringRef Sig1 = R
"cpp(
2615 EXPECT_THAT(signatures(Sig1).signatures,
2616 ElementsAre(sig("foo([[T]], [[T]], [[T]]) -> void")));
2618 StringRef Sig2 = R
"cpp(
2619 template <class ...T>
2627 EXPECT_THAT(signatures(Sig2).signatures,
2628 ElementsAre(sig("foo([[T...]]) -> void")));
2635 StringRef Sig3 = R
"cpp(
2643 X<int>().foo<double>(^)
2647 EXPECT_THAT(signatures(Sig3).signatures,
2648 ElementsAre(sig("foo([[T]], [[U]]) -> void")));
2651TEST(SignatureHelpTest, IndexDocumentation) {
2652 Symbol Foo0 =
sym(
"foo", index::SymbolKind::Function,
"@F@\\0#");
2653 Foo0.Documentation =
"doc from the index";
2654 Symbol Foo1 =
sym(
"foo", index::SymbolKind::Function,
"@F@\\0#I#");
2655 Foo1.Documentation =
"doc from the index";
2656 Symbol Foo2 =
sym(
"foo", index::SymbolKind::Function,
"@F@\\0#I#I#");
2658 StringRef Sig0 = R
"cpp(
2668 signatures(Sig0, {Foo0}).signatures,
2669 ElementsAre(AllOf(sig("foo() -> int"), sigDoc(
"doc from the index")),
2670 AllOf(sig(
"foo([[double]]) -> int"), sigDoc(
""))));
2672 StringRef Sig1 = R
"cpp(
2674 // Overriden doc from sema
2685 signatures(Sig1, {Foo0, Foo1, Foo2}).signatures,
2687 AllOf(sig("foo() -> int"), sigDoc(
"doc from the index")),
2688 AllOf(sig(
"foo([[int]]) -> int"), sigDoc(
"Overriden doc from sema")),
2689 AllOf(sig(
"foo([[int]], [[int]]) -> int"), sigDoc(
"doc from sema"))));
2692TEST(SignatureHelpTest, DynamicIndexDocumentation) {
2696 Opts.BuildDynamicSymbolIndex =
true;
2699 FS.Files[
testPath(
"foo.h")] = R
"cpp(
2713 Server.addDocument(
File, FileContent.code());
2715 ASSERT_TRUE(Server.blockUntilIdleForTest());
2719 ElementsAre(AllOf(sig(
"foo() -> int"), sigDoc(
"Member doc"))));
2722TEST(CompletionTest, ArgumentListsPolicy) {
2724 Opts.EnableSnippets =
true;
2728 auto Results = completions(
2731 void xfoo(int x, int y);
2732 void f() { xfo^ })cpp",
2735 Results.Completions,
2736 UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix(
"()")),
2737 AllOf(named(
"xfoo"), snippetSuffix(
"($0)"))));
2740 auto Results = completions(
2743 void f() { xba^ })cpp",
2745 EXPECT_THAT(Results.Completions, UnorderedElementsAre(AllOf(
2746 named("xbar"), snippetSuffix(
"()"))));
2749 Opts.BundleOverloads =
true;
2750 auto Results = completions(
2753 void xfoo(int x, int y);
2754 void f() { xfo^ })cpp",
2757 Results.Completions,
2758 UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix(
"($0)"))));
2761 auto Results = completions(
2763 template <class T, class U>
2764 void xfoo(int a, U b);
2765 void f() { xfo^ })cpp",
2768 Results.Completions,
2769 UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix(
"<$1>($0)"))));
2772 auto Results = completions(
2777 using foo_alias = T**;
2780 void f() { foo_^ })cpp",
2783 Results.Completions,
2784 UnorderedElementsAre(AllOf(named("foo_class"), snippetSuffix(
"<$0>")),
2785 AllOf(named(
"foo_alias"), snippetSuffix(
"<$0>")),
2786 AllOf(named(
"foo_var"), snippetSuffix(
"<$0>"))));
2789 auto Results = completions(
2791 #define FOO(x, y) x##f
2794 EXPECT_THAT(Results.Completions, UnorderedElementsAre(AllOf(
2795 named("FOO"), snippetSuffix(
"($0)"))));
2799 auto Results = completions(
2801 void xfoo(int x, int y);
2802 void f() { xfo^ })cpp",
2804 EXPECT_THAT(Results.Completions,
2805 UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix(
""))));
2809 auto Results = completions(
2811 void xfoo(int x, int y);
2812 void f() { xfo^ })cpp",
2814 EXPECT_THAT(Results.Completions,
2815 UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix(
"("))));
2819TEST(CompletionTest, SuggestOverrides) {
2820 constexpr const char *
const Text(R
"cpp(
2823 virtual void vfunc(bool param);
2824 virtual void vfunc(bool param, int p);
2825 void func(bool param);
2827 class B : public A {
2828 virtual void ttt(bool param) const;
2829 void vfunc(bool param, int p) override;
2831 class C : public B {
2833 void vfunc(bool param) override;
2837 const auto Results = completions(
Text);
2839 Results.Completions,
2840 AllOf(Contains(AllOf(labeled(
"void vfunc(bool param, int p) override"),
2841 nameStartsWith(
"vfunc"))),
2842 Contains(AllOf(labeled(
"void ttt(bool param) const override"),
2843 nameStartsWith(
"ttt"))),
2844 Not(Contains(labeled(
"void vfunc(bool param) override")))));
2847TEST(CompletionTest, OverridesNonIdentName) {
2851 virtual ~Base() = 0;
2852 virtual operator int() = 0;
2853 virtual Base& operator+(Base&) = 0;
2856 struct Derived : Base {
2862TEST(CompletionTest, NoCrashOnMissingNewLineAtEOF) {
2868 FS.Files[FooCpp] = F.code().str();
2873 clangd::CodeCompleteOptions()))
2882TEST(GuessCompletionPrefix, Filters) {
2883 for (llvm::StringRef Case : {
2884 "[[scope::]][[ident]]^",
2893 "some text [[scope::more::]][[identif]]^ier",
2894 "some text [[scope::]][[mor]]^e::identifier",
2895 "weird case foo::[[::bar::]][[baz]]^",
2900 auto ToStringRef = [&](
Range R) {
2904 auto WantQualifier = ToStringRef(F.ranges()[0]),
2905 WantName = ToStringRef(F.ranges()[1]);
2909 EXPECT_EQ(WantQualifier, Prefix.Qualifier) << Case;
2910 EXPECT_EQ(WantQualifier.begin(), Prefix.Qualifier.begin()) << Case;
2911 EXPECT_EQ(WantName, Prefix.Name) << Case;
2912 EXPECT_EQ(WantName.begin(), Prefix.Name.begin()) << Case;
2916TEST(CompletionTest, EnableSpeculativeIndexRequest) {
2923 namespace ns1 { int abc; }
2924 namespace ns2 { int abc; }
2925 void f() { ns1::ab$1^; ns1::ab$2^; }
2926 void f2() { ns2::ab$3^; }
2929 clangd::CodeCompleteOptions Opts = {};
2931 IndexRequestCollector Requests;
2932 Opts.Index = &Requests;
2934 auto CompleteAtPoint = [&](StringRef
P) {
2936 EXPECT_TRUE(CCR.HasMore);
2939 CompleteAtPoint(
"1");
2940 auto Reqs1 = Requests.consumeRequests(1);
2941 ASSERT_EQ(Reqs1.size(), 1u);
2942 EXPECT_THAT(Reqs1[0].Scopes, UnorderedElementsAre(
"ns1::"));
2944 CompleteAtPoint(
"2");
2945 auto Reqs2 = Requests.consumeRequests(1);
2947 ASSERT_EQ(Reqs2.size(), 1u);
2948 EXPECT_EQ(Reqs2[0], Reqs1[0]);
2950 CompleteAtPoint(
"3");
2953 auto Reqs3 = Requests.consumeRequests(2);
2954 ASSERT_EQ(Reqs3.size(), 2u);
2957TEST(CompletionTest, InsertTheMostPopularHeader) {
2960 Sym.CanonicalDeclaration.FileURI = DeclFile.c_str();
2964 auto Results = completions(
"Fun^", {Sym}).Completions;
2965 assert(!Results.empty());
2966 EXPECT_THAT(Results[0], AllOf(named(
"Func"), insertInclude(
"\"bar.h\"")));
2967 EXPECT_EQ(Results[0].Includes.size(), 2u);
2970TEST(CompletionTest, InsertIncludeOrImport) {
2973 Sym.CanonicalDeclaration.FileURI = DeclFile.c_str();
2974 Sym.IncludeHeaders.emplace_back(
"\"bar.h\"", 1000,
2978 Opts.ImportInsertions =
true;
2979 auto Results = completions(
"Fun^", {Sym}, Opts).Completions;
2980 assert(!Results.empty());
2981 EXPECT_THAT(Results[0],
2982 AllOf(named(
"Func"), insertIncludeText(
"#include \"bar.h\"\n")));
2986 Opts.MainFileSignals = &Signals;
2987 Results = completions(
"Fun^", {Sym}, Opts,
"Foo.m").Completions;
2988 assert(!Results.empty());
2989 EXPECT_THAT(Results[0],
2990 AllOf(named(
"Func"), insertIncludeText(
"#import \"bar.h\"\n")));
2993 Results = completions(
"Fun^", {Sym}).Completions;
2994 assert(!Results.empty());
2995 EXPECT_THAT(Results[0], AllOf(named(
"Func"), Not(insertInclude())));
2998TEST(CompletionTest, NoInsertIncludeIfOnePresent) {
3004 TU.AdditionalFiles[
"foo.h"] =
"";
3008 Sym.CanonicalDeclaration.FileURI = DeclFile.c_str();
3012 EXPECT_THAT(completions(TU, Test.point(), {Sym}).Completions,
3013 UnorderedElementsAre(AllOf(named(
"Func"), hasInclude(
"\"foo.h\""),
3014 Not(insertInclude()))));
3017TEST(CompletionTest, MergeMacrosFromIndexAndSema) {
3019 Sym.Name =
"Clangd_Macro_Test";
3020 Sym.ID =
SymbolID(
"c:foo.cpp@8@macro@Clangd_Macro_Test");
3021 Sym.SymInfo.Kind = index::SymbolKind::Macro;
3023 EXPECT_THAT(completions(
"#define Clangd_Macro_Test\nClangd_Macro_T^", {Sym})
3025 UnorderedElementsAre(named(
"Clangd_Macro_Test")));
3028TEST(CompletionTest, MacroFromPreamble) {
3029 Annotations Test(R
"cpp(#define CLANGD_PREAMBLE_MAIN x
3032 #define CLANGD_MAIN x
3033 void f() { CLANGD_^ }
3036 TU.HeaderCode =
"#define CLANGD_PREAMBLE_HEADER x";
3037 auto Results = completions(TU, Test.point(), {func(
"CLANGD_INDEX")});
3040 EXPECT_THAT(Results.Completions,
3041 UnorderedElementsAre(named(
"CLANGD_PREAMBLE_MAIN"),
3042 named(
"CLANGD_MAIN"),
3043 named(
"CLANGD_INDEX")));
3046TEST(CompletionTest, DeprecatedResults) {
3047 std::string Body = R
"cpp(
3049 void TestClangc() __attribute__((deprecated("", "")));
3053 completions(Body + "int main() { TestClang^ }").Completions,
3054 UnorderedElementsAre(AllOf(named(
"TestClangd"), Not(deprecated())),
3055 AllOf(named(
"TestClangc"), deprecated())));
3058TEST(SignatureHelpTest, PartialSpec) {
3059 const auto Results = signatures(R
"cpp(
3060 template <typename T> struct Foo {};
3061 template <typename T> struct Foo<T*> { Foo(T); };
3062 Foo<int*> F(^);)cpp");
3063 EXPECT_THAT(Results.signatures, Contains(sig("Foo([[T]])")));
3064 EXPECT_EQ(0, Results.activeParameter);
3067TEST(SignatureHelpTest, InsideArgument) {
3069 const auto Results = signatures(R
"cpp(
3071 void foo(int x, int y);
3072 int main() { foo(1+^); }
3074 EXPECT_THAT(Results.signatures,
3075 ElementsAre(sig("foo([[int x]]) -> void"),
3076 sig(
"foo([[int x]], [[int y]]) -> void")));
3077 EXPECT_EQ(0, Results.activeParameter);
3080 const auto Results = signatures(R
"cpp(
3082 void foo(int x, int y);
3083 int main() { foo(1^); }
3085 EXPECT_THAT(Results.signatures,
3086 ElementsAre(sig("foo([[int x]]) -> void"),
3087 sig(
"foo([[int x]], [[int y]]) -> void")));
3088 EXPECT_EQ(0, Results.activeParameter);
3091 const auto Results = signatures(R
"cpp(
3093 void foo(int x, int y);
3094 int main() { foo(1^0); }
3096 EXPECT_THAT(Results.signatures,
3097 ElementsAre(sig("foo([[int x]]) -> void"),
3098 sig(
"foo([[int x]], [[int y]]) -> void")));
3099 EXPECT_EQ(0, Results.activeParameter);
3102 const auto Results = signatures(R
"cpp(
3104 void foo(int x, int y);
3105 int bar(int x, int y);
3106 int main() { bar(foo(2, 3^)); }
3108 EXPECT_THAT(Results.signatures,
3109 ElementsAre(sig("foo([[int x]], [[int y]]) -> void")));
3110 EXPECT_EQ(1, Results.activeParameter);
3114TEST(SignatureHelpTest, ConstructorInitializeFields) {
3116 const auto Results = signatures(R
"cpp(
3117 struct A { A(int); };
3123 EXPECT_THAT(Results.signatures,
3124 UnorderedElementsAre(sig("A([[int]])"), sig(
"A([[A &&]])"),
3125 sig(
"A([[const A &]])")));
3128 const auto Results = signatures(R
"cpp(
3129 struct A { A(int); };
3137 EXPECT_THAT(Results.signatures, IsEmpty());
3140 const auto Results = signatures(R
"cpp(
3141 struct A { A(int); };
3148 EXPECT_THAT(Results.signatures,
3149 UnorderedElementsAre(sig("A([[int]])"), sig(
"A([[A &&]])"),
3150 sig(
"A([[const A &]])")));
3153 const auto Results = signatures(R
"cpp(
3162 B() : c_elem(A(1^)) {}
3166 EXPECT_THAT(Results.signatures,
3167 UnorderedElementsAre(sig("A([[int]])"), sig(
"A([[A &&]])"),
3168 sig(
"A([[const A &]])")));
3172TEST(SignatureHelpTest, Variadic) {
3173 const std::string Header = R
"cpp(
3174 void fun(int x, ...) {}
3176 const std::string ExpectedSig =
"fun([[int x]], [[...]]) -> void";
3179 const auto Result = signatures(Header +
"fun(^);}");
3180 EXPECT_EQ(0, Result.activeParameter);
3181 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3184 const auto Result = signatures(Header +
"fun(1, ^);}");
3185 EXPECT_EQ(1, Result.activeParameter);
3186 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3189 const auto Result = signatures(Header +
"fun(1, 2, ^);}");
3190 EXPECT_EQ(1, Result.activeParameter);
3191 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3195TEST(SignatureHelpTest, VariadicTemplate) {
3196 const std::string Header = R
"cpp(
3197 template<typename T, typename ...Args>
3198 void fun(T t, Args ...args) {}
3200 const std::string ExpectedSig =
"fun([[T t]], [[Args args...]]) -> void";
3203 const auto Result = signatures(Header +
"fun(^);}");
3204 EXPECT_EQ(0, Result.activeParameter);
3205 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3208 const auto Result = signatures(Header +
"fun(1, ^);}");
3209 EXPECT_EQ(1, Result.activeParameter);
3210 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3213 const auto Result = signatures(Header +
"fun(1, 2, ^);}");
3214 EXPECT_EQ(1, Result.activeParameter);
3215 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3219TEST(SignatureHelpTest, VariadicMethod) {
3220 const std::string Header = R
"cpp(
3222 template<typename T, typename ...Args>
3223 void fun(T t, Args ...args) {}
3225 void test() {C c; )cpp";
3226 const std::string ExpectedSig =
"fun([[T t]], [[Args args...]]) -> void";
3229 const auto Result = signatures(Header +
"c.fun(^);}");
3230 EXPECT_EQ(0, Result.activeParameter);
3231 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3234 const auto Result = signatures(Header +
"c.fun(1, ^);}");
3235 EXPECT_EQ(1, Result.activeParameter);
3236 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3239 const auto Result = signatures(Header +
"c.fun(1, 2, ^);}");
3240 EXPECT_EQ(1, Result.activeParameter);
3241 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3245TEST(SignatureHelpTest, VariadicType) {
3246 const std::string Header = R
"cpp(
3247 void fun(int x, ...) {}
3248 auto get_fun() { return fun; }
3251 const std::string ExpectedSig =
"([[int]], [[...]]) -> void";
3254 const auto Result = signatures(Header +
"get_fun()(^);}");
3255 EXPECT_EQ(0, Result.activeParameter);
3256 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3259 const auto Result = signatures(Header +
"get_fun()(1, ^);}");
3260 EXPECT_EQ(1, Result.activeParameter);
3261 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3264 const auto Result = signatures(Header +
"get_fun()(1, 2, ^);}");
3265 EXPECT_EQ(1, Result.activeParameter);
3266 EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
3270TEST(SignatureHelpTest, SkipExplicitObjectParameter) {
3273 void foo(this auto&& self, int arg);
3274 void bar(this A self, int arg);
3285 TU.ExtraArgs = {
"-std=c++23"};
3288 auto Inputs = TU.inputs(FS);
3297 EXPECT_EQ(1U, Result.signatures.size());
3299 EXPECT_THAT(Result.signatures[0], AllOf(sig(
"foo([[int arg]]) -> void")));
3305 EXPECT_EQ(1U, Result.signatures.size());
3307 EXPECT_THAT(Result.signatures[0], AllOf(sig(
"([[A]], [[int]]) -> void")));
3314 EXPECT_EQ(0U, Result.signatures.size());
3320TEST(CompletionTest, IncludedCompletionKinds) {
3323 TU.AdditionalFiles[
"sub/bar.h"] =
"";
3324 TU.ExtraArgs.push_back(
"-I" +
testPath(
"sub"));
3326 auto Results = completions(TU, Test.point());
3327 EXPECT_THAT(Results.Completions,
3332TEST(CompletionTest, NoCrashAtNonAlphaIncludeHeader) {
3339TEST(CompletionTest, NoAllScopesCompletionWhenQualified) {
3340 clangd::CodeCompleteOptions Opts = {};
3341 Opts.AllScopes = true;
3343 auto Results = completions(
3345 void f() { na::Clangd^ }
3347 {cls("na::ClangdA"),
cls(
"nx::ClangdX"),
cls(
"Clangd3")}, Opts);
3348 EXPECT_THAT(Results.Completions,
3349 UnorderedElementsAre(
3350 AllOf(qualifier(
""), scope(
"na::"), named(
"ClangdA"))));
3353TEST(CompletionTest, AllScopesCompletion) {
3354 clangd::CodeCompleteOptions Opts = {};
3355 Opts.AllScopes =
true;
3357 auto Results = completions(
3360 void f() { Clangd^ }
3363 {cls("nx::Clangd1"),
cls(
"ny::Clangd2"),
cls(
"Clangd3"),
3367 Results.Completions,
3368 UnorderedElementsAre(AllOf(qualifier(
"nx::"), named(
"Clangd1"),
3370 AllOf(qualifier(
"ny::"), named(
"Clangd2"),
3372 AllOf(qualifier(
""), scope(
""), named(
"Clangd3"),
3374 AllOf(qualifier(
"nb::"), named(
"Clangd4"),
3376 AllOf(qualifier(
"C::"), named(
"Clangd5"),
3380TEST(CompletionTest, NoCodePatternsIfDisabled) {
3381 clangd::CodeCompleteOptions Opts = {};
3382 Opts.EnableSnippets =
true;
3385 auto Results = completions(R
"cpp(
3394 EXPECT_THAT(Results.Completions,
3398TEST(CompletionTest, CompleteIncludeIfCodePatternsNone) {
3399 clangd::CodeCompleteOptions Opts = {};
3400 Opts.EnableSnippets =
true;
3405 TU.AdditionalFiles[
"foo/bar.h"] =
"";
3406 TU.ExtraArgs.push_back(
"-I" +
testPath(
"foo"));
3408 auto Results = completions(TU, Test.point(), {}, Opts);
3409 EXPECT_THAT(Results.Completions,
3414TEST(CompletionTest, NoQualifierIfShadowed) {
3415 clangd::CodeCompleteOptions Opts = {};
3416 Opts.AllScopes =
true;
3418 auto Results = completions(R
"cpp(
3419 namespace nx { class Clangd1 {}; }
3421 void f() { Clangd^ }
3423 {cls("nx::Clangd1"),
cls(
"nx::Clangd2")}, Opts);
3426 EXPECT_THAT(Results.Completions,
3427 UnorderedElementsAre(AllOf(qualifier(
""), named(
"Clangd1")),
3428 AllOf(qualifier(
"nx::"), named(
"Clangd2"))));
3431TEST(CompletionTest, NoCompletionsForNewNames) {
3432 clangd::CodeCompleteOptions Opts;
3433 Opts.AllScopes =
true;
3434 auto Results = completions(R
"cpp(
3437 {cls("naber"),
cls(
"nx::naber")}, Opts);
3438 EXPECT_THAT(Results.Completions, UnorderedElementsAre());
3441TEST(CompletionTest, Lambda) {
3442 clangd::CodeCompleteOptions Opts = {};
3444 auto Results = completions(R
"cpp(
3446 auto Lambda = [](int a, const double &b) {return 1.f;};
3452 ASSERT_EQ(Results.Completions.size(), 1u);
3453 const auto &
A = Results.Completions.front();
3454 EXPECT_EQ(
A.Name,
"Lambda");
3455 EXPECT_EQ(
A.Signature,
"(int a, const double &b) const");
3457 EXPECT_EQ(
A.ReturnType,
"float");
3458 EXPECT_EQ(
A.SnippetSuffix,
"(${1:int a}, ${2:const double &b})");
3461TEST(CompletionTest, StructuredBinding) {
3462 clangd::CodeCompleteOptions Opts = {};
3464 auto Results = completions(R
"cpp(
3466 using Float = float;
3471 const auto &[xxx, yyy] = S{};
3477 ASSERT_EQ(Results.Completions.size(), 1u);
3478 const auto &
A = Results.Completions.front();
3479 EXPECT_EQ(
A.Name,
"yyy");
3481 EXPECT_EQ(
A.ReturnType,
"const Float");
3484TEST(CompletionTest, ObjectiveCMethodNoArguments) {
3485 auto Results = completions(R
"objc(
3487 @property(nonatomic, setter=setXToIgnoreComplete:) int value;
3489 Foo *foo = [Foo new]; int y = [foo v^]
3494 auto C = Results.Completions;
3495 EXPECT_THAT(C, ElementsAre(named(
"value")));
3497 EXPECT_THAT(C, ElementsAre(returnType(
"int")));
3498 EXPECT_THAT(C, ElementsAre(signature(
"")));
3499 EXPECT_THAT(C, ElementsAre(snippetSuffix(
"")));
3502TEST(CompletionTest, ObjectiveCMethodOneArgument) {
3503 auto Results = completions(R
"objc(
3505 - (int)valueForCharacter:(char)c;
3507 Foo *foo = [Foo new]; int y = [foo v^]
3512 auto C = Results.Completions;
3513 EXPECT_THAT(C, ElementsAre(named(
"valueForCharacter:")));
3515 EXPECT_THAT(C, ElementsAre(returnType(
"int")));
3516 EXPECT_THAT(C, ElementsAre(signature(
"(char)")));
3517 EXPECT_THAT(C, ElementsAre(snippetSuffix(
"${1:(char)}")));
3520TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromBeginning) {
3521 auto Results = completions(R
"objc(
3523 + (id)fooWithValue:(int)value fooey:(unsigned int)fooey;
3530 auto C = Results.Completions;
3531 EXPECT_THAT(C, ElementsAre(named(
"fooWithValue:")));
3533 EXPECT_THAT(C, ElementsAre(returnType(
"id")));
3534 EXPECT_THAT(C, ElementsAre(signature(
"(int) fooey:(unsigned int)")));
3536 C, ElementsAre(snippetSuffix(
"${1:(int)} fooey:${2:(unsigned int)}")));
3539TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromMiddle) {
3540 auto Results = completions(R
"objc(
3542 + (id)fooWithValue:(int)value fooey:(unsigned int)fooey;
3544 id val = [Foo fooWithValue:10 f^]
3549 auto C = Results.Completions;
3550 EXPECT_THAT(C, ElementsAre(named(
"fooey:")));
3552 EXPECT_THAT(C, ElementsAre(returnType(
"id")));
3553 EXPECT_THAT(C, ElementsAre(signature(
"(unsigned int)")));
3554 EXPECT_THAT(C, ElementsAre(snippetSuffix(
"${1:(unsigned int)}")));
3557TEST(CompletionTest, ObjectiveCMethodFilterOnEntireSelector) {
3558 auto Results = completions(R
"objc(
3560 + (id)player:(id)player willRun:(id)run;
3567 auto C = Results.Completions;
3568 EXPECT_THAT(C, ElementsAre(named(
"player:")));
3569 EXPECT_THAT(C, ElementsAre(filterText(
"player:willRun:")));
3571 EXPECT_THAT(C, ElementsAre(returnType(
"id")));
3572 EXPECT_THAT(C, ElementsAre(signature(
"(id) willRun:(id)")));
3573 EXPECT_THAT(C, ElementsAre(snippetSuffix(
"${1:(id)} willRun:${2:(id)}")));
3576TEST(CompletionTest, ObjectiveCSimpleMethodDeclaration) {
3577 auto Results = completions(R
"objc(
3588 auto C = Results.Completions;
3589 EXPECT_THAT(C, ElementsAre(named(
"foo")));
3591 EXPECT_THAT(C, ElementsAre(qualifier(
"- (void)")));
3594TEST(CompletionTest, ObjectiveCMethodDeclaration) {
3595 auto Results = completions(R
"objc(
3597 - (int)valueForCharacter:(char)c secondArgument:(id)object;
3606 auto C = Results.Completions;
3607 EXPECT_THAT(C, ElementsAre(named(
"valueForCharacter:")));
3609 EXPECT_THAT(C, ElementsAre(qualifier(
"- (int)")));
3610 EXPECT_THAT(C, ElementsAre(signature(
"(char)c secondArgument:(id)object")));
3613TEST(CompletionTest, ObjectiveCMethodDeclarationFilterOnEntireSelector) {
3614 auto Results = completions(R
"objc(
3616 - (int)valueForCharacter:(char)c secondArgument:(id)object;
3625 auto C = Results.Completions;
3626 EXPECT_THAT(C, ElementsAre(named(
"valueForCharacter:")));
3627 EXPECT_THAT(C, ElementsAre(filterText(
"valueForCharacter:secondArgument:")));
3629 EXPECT_THAT(C, ElementsAre(qualifier(
"- (int)")));
3630 EXPECT_THAT(C, ElementsAre(signature(
"(char)c secondArgument:(id)object")));
3633TEST(CompletionTest, ObjectiveCMethodDeclarationPrefixTyped) {
3634 auto Results = completions(R
"objc(
3636 - (int)valueForCharacter:(char)c;
3645 auto C = Results.Completions;
3646 EXPECT_THAT(C, ElementsAre(named(
"valueForCharacter:")));
3648 EXPECT_THAT(C, ElementsAre(signature(
"(char)c")));
3651TEST(CompletionTest, ObjectiveCMethodDeclarationFromMiddle) {
3652 auto Results = completions(R
"objc(
3654 - (int)valueForCharacter:(char)c secondArgument:(id)object;
3657 - (int)valueForCharacter:(char)c second^
3663 auto C = Results.Completions;
3664 EXPECT_THAT(C, ElementsAre(named(
"secondArgument:")));
3666 EXPECT_THAT(C, ElementsAre(signature(
"(id)object")));
3669TEST(CompletionTest, ObjectiveCProtocolFromIndex) {
3673 auto Results = completions(
"id<Foo^>", {SymFood, FoodClass, SymFooey},
3677 EXPECT_THAT(Results.Completions,
3678 UnorderedElementsAre(
3682 Results = completions(
"Fo^", {SymFood, FoodClass, SymFooey},
3686 Results.Completions,
3690TEST(CompletionTest, ObjectiveCProtocolFromIndexSpeculation) {
3703 clangd::CodeCompleteOptions Opts = {};
3706 IndexRequestCollector Requests({FoodClass});
3707 Opts.Index = &Requests;
3709 auto CompleteAtPoint = [&](StringRef
P) {
3714 auto C = CompleteAtPoint(
"1");
3715 auto Reqs1 = Requests.consumeRequests(1);
3716 ASSERT_EQ(Reqs1.size(), 1u);
3717 EXPECT_THAT(C, ElementsAre(AllOf(named(
"Food"),
3720 C = CompleteAtPoint(
"2");
3721 auto Reqs2 = Requests.consumeRequests(1);
3724 ASSERT_EQ(Reqs2.size(), 1u);
3725 EXPECT_EQ(Reqs2[0], Reqs1[0]);
3726 EXPECT_THAT(C, ElementsAre(AllOf(named(
"FoodClass"),
3730TEST(CompletionTest, ObjectiveCCategoryFromIndexIgnored) {
3732 auto Results = completions(R
"objc(
3740 EXPECT_THAT(Results.Completions, IsEmpty());
3743TEST(CompletionTest, ObjectiveCForwardDeclFromIndex) {
3745 FoodClass.IncludeHeaders.emplace_back(
"\"Foo.h\"", 2,
Symbol::Import);
3747 auto Results = completions(
"@class Foo^", {SymFood, FoodClass},
3751 EXPECT_THAT(Results.Completions,
3752 UnorderedElementsAre(AllOf(named(
"FoodClass"),
3754 Not(insertInclude()))));
3757TEST(CompletionTest, CursorInSnippets) {
3758 clangd::CodeCompleteOptions Options;
3759 Options.EnableSnippets =
true;
3760 auto Results = completions(
3762 void while_foo(int a, int b);
3769 EXPECT_THAT(Results.Completions,
3770 Contains(AllOf(named(
"while"),
3771 snippetSuffix(
" (${1:condition}) {\n$0\n}"))));
3773 EXPECT_THAT(Results.Completions,
3774 Contains(AllOf(named(
"while_foo"),
3775 snippetSuffix(
"(${1:int a}, ${2:int b})"))));
3777 Results = completions(R
"cpp(
3779 Base(int a, int b) {}
3782 struct Derived : Base {
3789 EXPECT_THAT(Results.Completions,
3790 Contains(AllOf(named(
"Base"),
3791 snippetSuffix(
"(${1:int a}, ${2:int b})"))));
3794TEST(CompletionTest, WorksWithNullType) {
3795 auto R = completions(R
"cpp(
3797 for (auto [loopVar] : y ) { // y has to be unresolved.
3802 EXPECT_THAT(R.Completions, ElementsAre(named("loopVar")));
3805TEST(CompletionTest, UsingDecl) {
3806 const char *Header(R
"cpp(
3811 const char *Source(R
"cpp(
3816 clangd::CodeCompleteOptions Opts;
3817 Opts.Index = Index.get();
3818 Opts.AllScopes =
true;
3819 auto R = completions(Source, {}, Opts);
3820 EXPECT_THAT(R.Completions,
3821 ElementsAre(AllOf(scope(
"std::"), named(
"foo"),
3825TEST(CompletionTest, Enums) {
3826 const char *Header(R
"cpp(
3828 enum Unscoped { Clangd1 };
3830 enum Unscoped { Clangd2 };
3832 enum class Scoped { Clangd3 };
3834 const char *Source(R
"cpp(
3839 clangd::CodeCompleteOptions Opts;
3840 Opts.Index = Index.get();
3841 Opts.AllScopes =
true;
3842 auto R = completions(Source, {}, Opts);
3843 EXPECT_THAT(R.Completions, UnorderedElementsAre(
3844 AllOf(scope(
"ns::"), named(
"Clangd1"),
3846 AllOf(scope(
"ns::C::"), named(
"Clangd2"),
3848 AllOf(scope(
"ns::Scoped::"), named(
"Clangd3"),
3852TEST(CompletionTest, ScopeIsUnresolved) {
3853 clangd::CodeCompleteOptions Opts = {};
3854 Opts.AllScopes =
true;
3856 auto Results = completions(R
"cpp(
3861 {cls("a::b::XYZ")}, Opts);
3862 EXPECT_THAT(Results.Completions,
3863 UnorderedElementsAre(AllOf(qualifier(
""), named(
"XYZ"))));
3866TEST(CompletionTest, NestedScopeIsUnresolved) {
3867 clangd::CodeCompleteOptions Opts = {};
3868 Opts.AllScopes =
true;
3870 auto Results = completions(R
"cpp(
3873 void f() { b::c::X^ }
3876 {cls("a::b::c::XYZ")}, Opts);
3877 EXPECT_THAT(Results.Completions,
3878 UnorderedElementsAre(AllOf(qualifier(
""), named(
"XYZ"))));
3883TEST(CompletionTest, NamespaceDoubleInsertion) {
3884 clangd::CodeCompleteOptions Opts = {};
3886 auto Results = completions(R
"cpp(
3893 {cls("foo::ns::ABCDE")}, Opts);
3894 EXPECT_THAT(Results.Completions,
3895 UnorderedElementsAre(AllOf(qualifier(
""), named(
"ABCDE"))));
3898TEST(CompletionTest, DerivedMethodsAreAlwaysVisible) {
3901 auto Completions = completions(R
"cpp(
3904 double size() const;
3906 struct deque : deque_base {
3913 EXPECT_THAT(Completions,
3914 ElementsAre(AllOf(returnType("int"), named(
"size"))));
3917TEST(CompletionTest, NoCrashWithIncompleteLambda) {
3918 auto Completions = completions(
"auto&& x = []{^").Completions;
3922 EXPECT_THAT(Completions, Contains(named(
"x")));
3924 auto Signatures = signatures(
"auto x() { x(^").signatures;
3925 EXPECT_THAT(Signatures, Contains(sig(
"x() -> auto")));
3928TEST(CompletionTest, DelayedTemplateParsing) {
3931 template <typename T> int foo() { return xx^; }
3936 TU.ExtraArgs.push_back(
"-fdelayed-template-parsing");
3938 EXPECT_THAT(completions(TU, Test.point()).Completions,
3939 Contains(named(
"xxx")));
3942TEST(CompletionTest, CompletionRange) {
3943 const char *WithRange =
"auto x = [[abc]]^";
3944 auto Completions = completions(WithRange);
3945 EXPECT_EQ(Completions.CompletionRange,
Annotations(WithRange).range());
3946 Completions = completionsNoCompile(WithRange);
3947 EXPECT_EQ(Completions.CompletionRange,
Annotations(WithRange).range());
3949 const char *EmptyRange =
"auto x = [[]]^";
3950 Completions = completions(EmptyRange);
3951 EXPECT_EQ(Completions.CompletionRange,
Annotations(EmptyRange).range());
3952 Completions = completionsNoCompile(EmptyRange);
3953 EXPECT_EQ(Completions.CompletionRange,
Annotations(EmptyRange).range());
3957 const char *NoCompletion =
"/* foo [[]]^ */";
3958 Completions = completions(NoCompletion);
3959 EXPECT_EQ(Completions.CompletionRange, std::nullopt);
3960 Completions = completionsNoCompile(NoCompletion);
3961 EXPECT_EQ(Completions.CompletionRange,
Annotations(NoCompletion).range());
3964TEST(NoCompileCompletionTest, Basic) {
3965 auto Results = completionsNoCompile(R
"cpp(
3972 EXPECT_FALSE(Results.RanParser);
3973 EXPECT_THAT(Results.Completions,
3974 UnorderedElementsAre(named("void"), named(
"func"), named(
"int"),
3975 named(
"xyz"), named(
"abc")));
3978TEST(NoCompileCompletionTest, WithFilter) {
3979 auto Results = completionsNoCompile(R
"cpp(
3988 EXPECT_THAT(Results.Completions,
3989 UnorderedElementsAre(named("sym1"), named(
"sym2")));
3992TEST(NoCompileCompletionTest, WithIndex) {
3993 std::vector<Symbol> Syms = {
func(
"xxx"),
func(
"a::xxx"),
func(
"ns::b::xxx"),
3994 func(
"c::xxx"),
func(
"ns::d::xxx")};
3995 auto Results = completionsNoCompile(
3997 // Current-scopes, unqualified completion.
4007 EXPECT_THAT(Results.Completions,
4008 UnorderedElementsAre(AllOf(qualifier(""), scope(
"")),
4009 AllOf(qualifier(
""), scope(
"a::")),
4010 AllOf(qualifier(
""), scope(
"ns::b::"))));
4012 Opts.AllScopes =
true;
4013 Results = completionsNoCompile(
4015 // All-scopes unqualified completion.
4025 EXPECT_THAT(Results.Completions,
4026 UnorderedElementsAre(AllOf(qualifier(""), scope(
"")),
4027 AllOf(qualifier(
""), scope(
"a::")),
4028 AllOf(qualifier(
""), scope(
"ns::b::")),
4029 AllOf(qualifier(
"c::"), scope(
"c::")),
4030 AllOf(qualifier(
"d::"), scope(
"ns::d::"))));
4031 Results = completionsNoCompile(
4033 // Qualified completion.
4043 EXPECT_THAT(Results.Completions,
4044 ElementsAre(AllOf(qualifier(""), scope(
"ns::b::"))));
4045 Results = completionsNoCompile(
4047 // Absolutely qualified completion.
4057 EXPECT_THAT(Results.Completions,
4058 ElementsAre(AllOf(qualifier(""), scope(
"a::"))));
4061TEST(AllowImplicitCompletion,
All) {
4062 const char *
Yes[] = {
4066 " # include <^foo.h>",
4067 "#import <foo/^bar.h>",
4068 "#include_next \"^",
4070 const char *
No[] = {
4074 "#include <foo.h> //^",
4075 "#include \"foo.h\"^",
4079 for (
const char *Test :
Yes) {
4080 llvm::Annotations
A(Test);
4083 for (
const char *Test :
No) {
4084 llvm::Annotations
A(Test);
4089TEST(CompletionTest, FunctionArgsExist) {
4090 clangd::CodeCompleteOptions Opts;
4091 Opts.EnableSnippets =
true;
4099 template <typename T>
4101 Container(int Size) {}
4104 EXPECT_THAT(completions(Context + "int y = fo^", {}, Opts).Completions,
4105 UnorderedElementsAre(
4106 AllOf(labeled(
"foo(int A)"), snippetSuffix(
"(${1:int A})"))));
4108 completions(
Context +
"int y = fo^(42)", {}, Opts).Completions,
4109 UnorderedElementsAre(AllOf(labeled(
"foo(int A)"), snippetSuffix(
""))));
4111 EXPECT_THAT(completions(
Context +
"int y = fo^o(42)", {}, Opts).Completions,
4112 UnorderedElementsAre(
4113 AllOf(labeled(
"foo(int A)"), snippetSuffix(
"(${1:int A})"))));
4115 completions(
Context +
"int y = ba^", {}, Opts).Completions,
4116 UnorderedElementsAre(AllOf(labeled(
"bar()"), snippetSuffix(
"()"))));
4117 EXPECT_THAT(completions(
Context +
"int y = ba^()", {}, Opts).Completions,
4118 UnorderedElementsAre(AllOf(labeled(
"bar()"), snippetSuffix(
""))));
4120 completions(
Context +
"Object o = Obj^", {}, Opts).Completions,
4121 Contains(AllOf(labeled(
"Object(int B)"), snippetSuffix(
"(${1:int B})"),
4123 EXPECT_THAT(completions(
Context +
"Object o = Obj^()", {}, Opts).Completions,
4124 Contains(AllOf(labeled(
"Object(int B)"), snippetSuffix(
""),
4127 completions(
Context +
"Container c = Cont^", {}, Opts).Completions,
4128 Contains(AllOf(labeled(
"Container<typename T>(int Size)"),
4129 snippetSuffix(
"<${1:typename T}>(${2:int Size})"),
4132 completions(
Context +
"Container c = Cont^()", {}, Opts).Completions,
4133 Contains(AllOf(labeled(
"Container<typename T>(int Size)"),
4134 snippetSuffix(
"<${1:typename T}>"),
4137 completions(
Context +
"Container c = Cont^<int>()", {}, Opts).Completions,
4138 Contains(AllOf(labeled(
"Container<typename T>(int Size)"),
4141 EXPECT_THAT(completions(
Context +
"MAC^(2)", {}, Opts).Completions,
4142 Contains(AllOf(labeled(
"MACRO(x)"), snippetSuffix(
""),
4146TEST(CompletionTest, FunctionArgsExist_Issue1785) {
4150 clangd::CodeCompleteOptions Opts;
4151 Opts.EnableSnippets =
true;
4153 std::string Code = R
"cpp(
4165 completions(Code, {}, Opts).Completions,
4166 Contains(AllOf(labeled("waldo(int)"), snippetSuffix(
"(${1:int})"))));
4169TEST(CompletionTest, NoCrashDueToMacroOrdering) {
4170 EXPECT_THAT(completions(R
"cpp(
4172 #define ECHO2(X) ECHO(X)
4173 int finish_preamble = EC^HO(2);)cpp")
4175 UnorderedElementsAre(labeled("ECHO(X)"), labeled(
"ECHO2(X)")));
4178TEST(CompletionTest, ObjCCategoryDecls) {
4180 TU.
ExtraArgs.push_back(
"-xobjective-c");
4181 TU.HeaderCode = R
"objc(
4185 @interface Foo (FooExt1)
4188 @interface Foo (FooExt2)
4194 @interface Bar (BarExt)
4199 @implementation Foo (^)
4202 TU.Code = Test.code().str();
4203 auto Results = completions(TU, Test.point());
4204 EXPECT_THAT(Results.Completions,
4205 UnorderedElementsAre(labeled(
"FooExt1"), labeled(
"FooExt2")));
4212 TU.Code = Test.code().str();
4213 auto Results = completions(TU, Test.point());
4214 EXPECT_THAT(Results.Completions, UnorderedElementsAre(labeled(
"BarExt")));
4218TEST(CompletionTest, PreambleCodeComplete) {
4219 llvm::StringLiteral Baseline =
"\n#define MACRO 12\nint num = MACRO;";
4220 llvm::StringLiteral ModifiedCC =
4221 "#include \"header.h\"\n#define MACRO 12\nint num = MACRO; int num2 = M^";
4228 auto Inputs = ModifiedTU.inputs(FS);
4230 BaselineTU.preamble().get(), Inputs, {});
4231 EXPECT_THAT(Result.Completions, Not(testing::IsEmpty()));
4234TEST(CompletionTest, CommentParamName) {
4235 const std::string Code = R
"cpp(
4236 void fun(int foo, int bar);
4237 void overloaded(int param_int);
4238 void overloaded(int param_int, int param_other);
4239 void overloaded(char param_char);
4243 EXPECT_THAT(completions(Code + "fun(/*^").Completions,
4244 UnorderedElementsAre(labeled(
"foo=*/")));
4245 EXPECT_THAT(completions(Code +
"fun(1, /*^").Completions,
4246 UnorderedElementsAre(labeled(
"bar=*/")));
4247 EXPECT_THAT(completions(Code +
"/*^").Completions, IsEmpty());
4250 completions(Code +
"overloaded(/*^").Completions,
4251 UnorderedElementsAre(labeled(
"param_int=*/"), labeled(
"param_char=*/")));
4253 EXPECT_THAT(completions(Code +
"fun(/* ^").Completions,
4254 UnorderedElementsAre(labeled(
"foo=*/")));
4255 EXPECT_THAT(completions(Code +
"fun(/* f^").Completions,
4256 UnorderedElementsAre(labeled(
"foo=*/")));
4257 EXPECT_THAT(completions(Code +
"fun(/* x^").Completions, IsEmpty());
4258 EXPECT_THAT(completions(Code +
"fun(/* f ^").Completions, IsEmpty());
4262 std::string CompletionRangeTest(Code +
"fun(/*[[^]]");
4263 auto Results = completions(CompletionRangeTest);
4264 EXPECT_THAT(Results.CompletionRange,
4265 llvm::ValueIs(
Annotations(CompletionRangeTest).range()));
4267 Results.Completions,
4269 AllOf(replacesRange(
Annotations(CompletionRangeTest).range()),
4273 std::string CompletionRangeTest(Code +
"fun(/*[[fo^]]");
4274 auto Results = completions(CompletionRangeTest);
4275 EXPECT_THAT(Results.CompletionRange,
4276 llvm::ValueIs(
Annotations(CompletionRangeTest).range()));
4278 Results.Completions,
4280 AllOf(replacesRange(
Annotations(CompletionRangeTest).range()),
4285TEST(CompletionTest, Concepts) {
4288 concept A = sizeof(T) <= 8;
4290 template<$tparam^A U>
4293 template<typename T>
4294 int bar(T t) requires $expr^A<int>;
4297 concept b = $expr^A && $expr^sizeof(T) % 2 == 0 || $expr^A && sizeof(T) == 1;
4299 $toplevel^A auto i = 19;
4301 template<$toplevel^A auto i> void constrainedNTTP();
4303 // FIXME: The first parameter should be dropped in this case.
4304 void abbreviated($expr^A auto x) {}
4307 TU.Code = Code.code().str();
4308 TU.ExtraArgs = {"-std=c++20"};
4311 Sym.Signature =
"<typename Tp, typename Up>";
4312 Sym.CompletionSnippetSuffix =
"<${1:typename Tp}, ${2:typename Up}>";
4313 std::vector<Symbol> Syms = {Sym};
4314 for (
auto P : Code.points(
"tparam")) {
4316 completions(TU, P, Syms).Completions,
4317 AllOf(Contains(AllOf(named(
"A"), signature(
""), snippetSuffix(
""))),
4318 Contains(AllOf(named(
"same_as"), signature(
"<typename Up>"),
4319 snippetSuffix(
"<${2:typename Up}>"))),
4320 Contains(named(
"class")), Contains(named(
"typename"))))
4321 <<
"Completing template parameter at position " <<
P;
4324 for (
auto P : Code.points(
"toplevel")) {
4326 completions(TU, P, Syms).Completions,
4327 AllOf(Contains(AllOf(named(
"A"), signature(
""), snippetSuffix(
""))),
4328 Contains(AllOf(named(
"same_as"), signature(
"<typename Up>"),
4329 snippetSuffix(
"<${2:typename Up}>")))))
4330 <<
"Completing 'requires' expression at position " <<
P;
4333 for (
auto P : Code.points(
"expr")) {
4335 completions(TU, P, Syms).Completions,
4336 AllOf(Contains(AllOf(named(
"A"), signature(
"<class T>"),
4337 snippetSuffix(
"<${1:class T}>"))),
4339 named(
"same_as"), signature(
"<typename Tp, typename Up>"),
4340 snippetSuffix(
"<${1:typename Tp}, ${2:typename Up}>")))))
4341 <<
"Completing 'requires' expression at position " <<
P;
4347 // Comment `with` markup.
4349 void bar() { foo(^); }
4351 for (
auto DocumentationFormat :
4353 auto Sigs = signatures(Code.code(), Code.point(), {},
4354 DocumentationFormat);
4355 ASSERT_EQ(Sigs.signatures.size(), 1U);
4356 EXPECT_EQ(Sigs.signatures[0].documentation.kind, DocumentationFormat);
4361 std::string Top = R
"cpp(
4362 template <typename T, int> bool foo(char);
4363 template <int I, int> bool foo(float);
4366 auto First = signatures(Top +
"bool x = foo<^");
4369 UnorderedElementsAre(sig(
"foo<[[typename T]], [[int]]>() -> bool"),
4370 sig(
"foo<[[int I]], [[int]]>() -> bool")));
4371 EXPECT_EQ(First.activeParameter, 0);
4373 auto Second = signatures(Top +
"bool x = foo<1, ^");
4374 EXPECT_THAT(Second.signatures,
4375 ElementsAre(sig(
"foo<[[int I]], [[int]]>() -> bool")));
4376 EXPECT_EQ(Second.activeParameter, 1);
4379TEST(CompletionTest, DoNotCrash) {
4380 llvm::StringLiteral Cases[] = {
4382 template <typename = int> struct Foo {};
4383 auto a = [x(3)](Foo<^>){};
4386 for (
auto Case : Cases) {
4388 auto Completions = completions(Case);
4391TEST(CompletionTest, PreambleFromDifferentTarget) {
4392 constexpr std::string_view PreambleTarget =
"x86_64";
4393 constexpr std::string_view Contents =
4394 "int foo(int); int num; int num2 = foo(n^";
4398 TU.ExtraArgs.emplace_back(
"-target");
4399 TU.ExtraArgs.emplace_back(PreambleTarget);
4403 TU.ExtraArgs.pop_back();
4404 TU.ExtraArgs.emplace_back(
"wasm32");
4407 auto Inputs = TU.inputs(FS);
4414 EXPECT_THAT(Result.Completions, Not(testing::IsEmpty()));
4415 EXPECT_THAT(Signatures.signatures, Not(testing::IsEmpty()));
4418TEST(CompletionTest, SkipExplicitObjectParameter) {
4421 void foo(this auto&& self, int arg);
4422 void bar(this A self, int arg);
4441 TU.ExtraArgs = {
"-std=c++23"};
4449 auto Inputs = TU.inputs(FS);
4454 EXPECT_THAT(Result.Completions,
4455 UnorderedElementsAre(AllOf(named(
"foo"), signature(
"(int arg)"),
4456 snippetSuffix(
"(${1:int arg})")),
4457 AllOf(named(
"bar"), signature(
"(int arg)"),
4458 snippetSuffix(
"(${1:int arg})"))));
4465 ElementsAre(AllOf(named(
"foo"), signature(
"<class self:auto>(int arg)"),
4466 snippetSuffix(
"<${1:class self:auto}>"))));
4471 EXPECT_THAT(Result.Completions,
4472 ElementsAre(AllOf(named(
"bar"), signature(
"(int arg)"),
4473 snippetSuffix(
""))));
4477TEST(CompletionTest, MemberAccessInExplicitObjMemfn) {
4481 int memberFnA(int a);
4482 int memberFnA(this A&, float a);
4484 void foo(this A& self) {
4485 // Should not offer any members here, since
4486 // it needs to be referenced through `self`.
4488 // should offer all results
4492 // should not offer any results
4500 TU.ExtraArgs = {
"-std=c++23"};
4508 auto Inputs = TU.inputs(FS);
4514 EXPECT_THAT(Result.Completions, ElementsAre());
4522 UnorderedElementsAre(named(
"member"),
4523 AllOf(named(
"memberFnA"), signature(
"(int a)"),
4524 snippetSuffix(
"(${1:int a})")),
4525 AllOf(named(
"memberFnA"), signature(
"(float a)"),
4526 snippetSuffix(
"(${1:float a})"))));
4532 EXPECT_THAT(Result.Completions, ElementsAre());
4536TEST(CompletionTest, ListExplicitObjectOverloads) {
4540 void foo2(int a) const;
4541 void foo2(this const S& self, float a);
4542 void foo3(this const S& self, int a);
4543 void foo4(this S& self, int a);
4546 void S::foo1(int a) {
4550 void S::foo2(int a) const {
4554 void S::foo3(this const S& self, int a) {
4558 void S::foo4(this S& self, int a) {
4566 void test2(const S s) {
4572 TU.ExtraArgs = {
"-std=c++23"};
4580 auto Inputs = TU.inputs(FS);
4587 UnorderedElementsAre(AllOf(named(
"foo1"), signature(
"(int a)"),
4588 snippetSuffix(
"(${1:int a})")),
4589 AllOf(named(
"foo2"), signature(
"(int a) const"),
4590 snippetSuffix(
"(${1:int a})")),
4591 AllOf(named(
"foo2"), signature(
"(float a) const"),
4592 snippetSuffix(
"(${1:float a})")),
4593 AllOf(named(
"foo3"), signature(
"(int a) const"),
4594 snippetSuffix(
"(${1:int a})")),
4595 AllOf(named(
"foo4"), signature(
"(int a)"),
4596 snippetSuffix(
"(${1:int a})"))));
4603 UnorderedElementsAre(AllOf(named(
"foo2"), signature(
"(int a) const"),
4604 snippetSuffix(
"(${1:int a})")),
4605 AllOf(named(
"foo2"), signature(
"(float a) const"),
4606 snippetSuffix(
"(${1:float a})")),
4607 AllOf(named(
"foo3"), signature(
"(int a) const"),
4608 snippetSuffix(
"(${1:int a})"))));
4615 UnorderedElementsAre(AllOf(named(
"foo2"), signature(
"(int a) const"),
4616 snippetSuffix(
"(${1:int a})")),
4617 AllOf(named(
"foo2"), signature(
"(float a) const"),
4618 snippetSuffix(
"(${1:float a})")),
4619 AllOf(named(
"foo3"), signature(
"(int a) const"),
4620 snippetSuffix(
"(${1:int a})"))));
4627 UnorderedElementsAre(AllOf(named(
"foo1"), signature(
"(int a)"),
4628 snippetSuffix(
"(${1:int a})")),
4629 AllOf(named(
"foo2"), signature(
"(int a) const"),
4630 snippetSuffix(
"(${1:int a})")),
4631 AllOf(named(
"foo2"), signature(
"(float a) const"),
4632 snippetSuffix(
"(${1:float a})")),
4633 AllOf(named(
"foo3"), signature(
"(int a) const"),
4634 snippetSuffix(
"(${1:int a})")),
4635 AllOf(named(
"foo4"), signature(
"(int a)"),
4636 snippetSuffix(
"(${1:int a})"))));
4643 UnorderedElementsAre(AllOf(named(
"foo1"), signature(
"(int a)"),
4644 snippetSuffix(
"(${1:int a})")),
4645 AllOf(named(
"foo2"), signature(
"(int a) const"),
4646 snippetSuffix(
"(${1:int a})")),
4647 AllOf(named(
"foo2"), signature(
"(float a) const"),
4648 snippetSuffix(
"(${1:float a})")),
4649 AllOf(named(
"foo3"), signature(
"(int a) const"),
4650 snippetSuffix(
"(${1:int a})")),
4651 AllOf(named(
"foo4"), signature(
"(int a)"),
4652 snippetSuffix(
"(${1:int a})"))));
4659 UnorderedElementsAre(AllOf(named(
"foo2"), signature(
"(int a) const"),
4660 snippetSuffix(
"(${1:int a})")),
4661 AllOf(named(
"foo2"), signature(
"(float a) const"),
4662 snippetSuffix(
"(${1:float a})")),
4663 AllOf(named(
"foo3"), signature(
"(int a) const"),
4664 snippetSuffix(
"(${1:int a})"))));
#define EXPECT_IFF(condition, value, matcher)
Same as llvm::Annotations, but adjusts functions to LSP-specific types for positions and ranges.
clangd::Range range(llvm::StringRef Name="") const
Manages a collection of source files and derived data (ASTs, indexes), and provides language-aware fe...
static Options optsForTest()
A context is an immutable container for per-request data that must be propagated through layers that ...
static std::unique_ptr< SymbolIndex > build(SymbolSlab Symbols, RefSlab Refs, RelationSlab Relations)
Builds an index from slabs. The index takes ownership of the data.
llvm::StringMap< std::string > Files
An efficient structure of storing large set of symbol references in memory.
Interface for symbol indexes that can be used for searching or matching symbols among a set of symbol...
SymbolSlab::Builder is a mutable container that can 'freeze' to SymbolSlab.
void insert(const Symbol &S)
Adds a symbol, overwriting any existing one with the same ID.
static llvm::Expected< URI > create(llvm::StringRef AbsolutePath, llvm::StringRef Scheme)
Creates a URI for a file in the given scheme.
WithContextValue extends Context::current() with a single value.
FIXME: Skip testing on windows temporarily due to the different escaping code mode.
Symbol objcProtocol(llvm::StringRef Name)
Symbol objcClass(llvm::StringRef Name)
Symbol func(llvm::StringRef Name)
Symbol cls(llvm::StringRef Name)
Symbol objcCategory(llvm::StringRef Name, llvm::StringRef CategoryName)
std::string sortText(float Score, llvm::StringRef Name)
Returns a string that sorts in the same order as (-Score, Tiebreak), for LSP.
Symbol conceptSym(llvm::StringRef Name)
IndexContents
Describes what data is covered by an index.
size_t lspLength(llvm::StringRef Code)
CompletionPrefix guessCompletionPrefix(llvm::StringRef Content, unsigned Offset)
std::unique_ptr< CompilerInvocation > buildCompilerInvocation(const ParseInputs &Inputs, clang::DiagnosticConsumer &D, std::vector< std::string > *CC1Args)
Builds compiler invocation that could be used to build AST or preamble.
Symbol sym(llvm::StringRef QName, index::SymbolKind Kind, llvm::StringRef USRFormat, llvm::StringRef Signature)
CompletionItemKind
The kind of a completion entry.
Symbol ns(llvm::StringRef Name)
bool allowImplicitCompletion(llvm::StringRef Content, unsigned Offset)
llvm::unique_function< void(llvm::Expected< T >)> Callback
A Callback<T> is a void function that accepts Expected<T>.
llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, const CodeCompletion &C)
llvm::Expected< CodeCompleteResult > runCodeComplete(ClangdServer &Server, PathRef File, Position Pos, clangd::CodeCompleteOptions Opts)
llvm::Expected< SignatureHelp > runSignatureHelp(ClangdServer &Server, PathRef File, Position Pos, MarkupKind DocumentationFormat)
std::string testPath(PathRef File, llvm::sys::path::Style Style)
std::shared_ptr< const PreambleData > buildPreamble(PathRef FileName, CompilerInvocation CI, const ParseInputs &Inputs, bool StoreInMemory, PreambleParsedCallback PreambleCallback, PreambleBuildStats *Stats)
Build a preamble for the new inputs unless an old one can be reused.
TEST(BackgroundQueueTest, Priority)
void wait(std::unique_lock< std::mutex > &Lock, std::condition_variable &CV, Deadline D)
Wait once on CV for the specified duration.
llvm::Expected< size_t > positionToOffset(llvm::StringRef Code, Position P, bool AllowColumnsBeyondLineLength)
Turn a [line, column] pair into an offset in Code.
void runAddDocument(ClangdServer &Server, PathRef File, llvm::StringRef Contents, llvm::StringRef Version, WantDiagnostics WantDiags, bool ForceRebuild)
Symbol macro(llvm::StringRef Name, llvm::StringRef ArgList)
llvm::StringRef PathRef
A typedef to represent a ref to file path.
@ No
Diagnostics must be generated for this snapshot.
std::vector< std::string > lookup(const SymbolIndex &I, llvm::ArrayRef< SymbolID > IDs)
Symbol enmConstant(llvm::StringRef Name)
Deadline timeoutSeconds(std::optional< double > Seconds)
Makes a deadline from a timeout in seconds. std::nullopt means wait forever.
CodeCompleteResult codeComplete(PathRef FileName, Position Pos, const PreambleData *Preamble, const ParseInputs &ParseInput, CodeCompleteOptions Opts, SpeculativeFuzzyFind *SpecFuzzyFind)
Gets code completions at a specified Pos in FileName.
@ PlainText
The primary text to be inserted is treated as a plain string.
@ Snippet
The primary text to be inserted is treated as a snippet.
SignatureHelp signatureHelp(PathRef FileName, Position Pos, const PreambleData &Preamble, const ParseInputs &ParseInput, MarkupKind DocumentationFormat)
Get signature help at a specified Pos in FileName.
PolySubsequenceMatcher< Args... > HasSubsequence(Args &&... M)
Symbol var(llvm::StringRef Name)
cppcoreguidelines::ProBoundsAvoidUncheckedContainerAccess P
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Signals derived from a valid AST of a file.
llvm::DenseMap< SymbolID, unsigned > ReferencedSymbols
Number of occurrences of each symbol present in the file.
Symbol::IncludeDirective InsertionDirective
Preferred preprocessor directive to use for inclusions by the file.
Represents a collection of completion items to be presented in the editor.
Settings that express user/project preferences and control clangd behavior.
static clangd::Key< Config > Key
Context key which can be used to set the current Config.
@ None
nothing, no argument list and also NO Delimiters "()" or "<>".
@ Delimiters
empty pair of delimiters "()" or "<>".
@ OpenDelimiter
open, only opening delimiter "(" or "<".
Same semantics as CodeComplete::Score.
std::vector< std::string > Scopes
If this is non-empty, symbols must be in at least one of the scopes (e.g.
int line
Line position in a document (zero-based).
int character
Character offset on a line in a document (zero-based).
Position end
The range's end position.
Represents the signature of a callable.
Attributes of a symbol that affect how much we like it.
Attributes of a symbol-query pair that affect how much we like it.
The class presents a C++ symbol, e.g.
@ IndexedForCodeCompletion
Whether or not this symbol is meant to be used for the code completion.
@ Include
#include "header.h"
@ Import
#import "header.h"
SymbolID ID
The ID of the symbol.
std::vector< std::string > ExtraArgs
static TestTU withHeaderCode(llvm::StringRef HeaderCode)
static TestTU withCode(llvm::StringRef Code)
llvm::StringMap< std::string > AdditionalFiles
std::unique_ptr< SymbolIndex > index() const
Range range
The range of the text document to be manipulated.