| 1 |
//===-- CodeCompletionStringsTests.cpp --------------------------*- C++ -*-===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
|
| 9 |
#include "CodeCompletionStrings.h" |
| 10 |
#include "TestTU.h" |
| 11 |
#include "clang/Sema/CodeCompleteConsumer.h" |
| 12 |
#include "gmock/gmock.h" |
| 13 |
#include "gtest/gtest.h" |
| 14 |
|
| 15 |
namespace clang { |
| 16 |
namespace clangd { |
| 17 |
namespace { |
| 18 |
|
| 19 |
class CompletionStringTest : public ::testing::Test { |
| 20 |
public: |
| 21 |
CompletionStringTest() |
| 22 |
: Allocator(std::make_shared<clang::GlobalCodeCompletionAllocator>()), |
| 23 |
CCTUInfo(Allocator), Builder(*Allocator, CCTUInfo) {} |
| 24 |
|
| 25 |
protected: |
| 26 |
void computeSignature(const CodeCompletionString &CCS, |
| 27 |
bool CompletingPattern = false) { |
| 28 |
Signature.clear(); |
| 29 |
Snippet.clear(); |
| 30 |
getSignature(CCS, &Signature, &Snippet, /*RequiredQualifier=*/nullptr, |
| 31 |
CompletingPattern); |
| 32 |
} |
| 33 |
|
| 34 |
std::shared_ptr<clang::GlobalCodeCompletionAllocator> Allocator; |
| 35 |
CodeCompletionTUInfo CCTUInfo; |
| 36 |
CodeCompletionBuilder Builder; |
| 37 |
std::string Signature; |
| 38 |
std::string Snippet; |
| 39 |
}; |
| 40 |
|
| 41 |
TEST_F(CompletionStringTest, ReturnType) { |
| 42 |
Builder.AddResultTypeChunk("result"); |
| 43 |
Builder.AddResultTypeChunk("redundant result no no"); |
| 44 |
EXPECT_EQ(getReturnType(*Builder.TakeString()), "result"); |
| 45 |
} |
| 46 |
|
| 47 |
TEST_F(CompletionStringTest, Documentation) { |
| 48 |
Builder.addBriefComment("This is ignored"); |
| 49 |
EXPECT_EQ(formatDocumentation(*Builder.TakeString(), "Is this brief?"), |
| 50 |
"Is this brief?"); |
| 51 |
} |
| 52 |
|
| 53 |
TEST_F(CompletionStringTest, DocumentationWithAnnotation) { |
| 54 |
Builder.addBriefComment("This is ignored"); |
| 55 |
Builder.AddAnnotation("Ano"); |
| 56 |
EXPECT_EQ(formatDocumentation(*Builder.TakeString(), "Is this brief?"), |
| 57 |
"Annotation: Ano\n\nIs this brief?"); |
| 58 |
} |
| 59 |
|
| 60 |
TEST_F(CompletionStringTest, GetDeclCommentBadUTF8) { |
| 61 |
// <ff> is not a valid byte here, should be replaced by encoded <U+FFFD>. |
| 62 |
auto TU = TestTU::withCode("/*x\xffy*/ struct X;"); |
| 63 |
auto AST = TU.build(); |
| 64 |
EXPECT_EQ("x\xef\xbf\xbdy", |
| 65 |
getDeclComment(AST.getASTContext(), findDecl(AST, "X"))); |
| 66 |
} |
| 67 |
|
| 68 |
TEST_F(CompletionStringTest, MultipleAnnotations) { |
| 69 |
Builder.AddAnnotation("Ano1"); |
| 70 |
Builder.AddAnnotation("Ano2"); |
| 71 |
Builder.AddAnnotation("Ano3"); |
| 72 |
|
| 73 |
EXPECT_EQ(formatDocumentation(*Builder.TakeString(), ""), |
| 74 |
"Annotations: Ano1 Ano2 Ano3\n"); |
| 75 |
} |
| 76 |
|
| 77 |
TEST_F(CompletionStringTest, EmptySignature) { |
| 78 |
Builder.AddTypedTextChunk("X"); |
| 79 |
Builder.AddResultTypeChunk("result no no"); |
| 80 |
computeSignature(*Builder.TakeString()); |
| 81 |
EXPECT_EQ(Signature, ""); |
| 82 |
EXPECT_EQ(Snippet, ""); |
| 83 |
} |
| 84 |
|
| 85 |
TEST_F(CompletionStringTest, Function) { |
| 86 |
Builder.AddResultTypeChunk("result no no"); |
| 87 |
Builder.addBriefComment("This comment is ignored"); |
| 88 |
Builder.AddTypedTextChunk("Foo"); |
| 89 |
Builder.AddChunk(CodeCompletionString::CK_LeftParen); |
| 90 |
Builder.AddPlaceholderChunk("p1"); |
| 91 |
Builder.AddChunk(CodeCompletionString::CK_Comma); |
| 92 |
Builder.AddPlaceholderChunk("p2"); |
| 93 |
Builder.AddChunk(CodeCompletionString::CK_RightParen); |
| 94 |
|
| 95 |
auto *CCS = Builder.TakeString(); |
| 96 |
computeSignature(*CCS); |
| 97 |
EXPECT_EQ(Signature, "(p1, p2)"); |
| 98 |
EXPECT_EQ(Snippet, "(${1:p1}, ${2:p2})"); |
| 99 |
EXPECT_EQ(formatDocumentation(*CCS, "Foo's comment"), "Foo's comment"); |
| 100 |
} |
| 101 |
|
| 102 |
TEST_F(CompletionStringTest, FunctionWithDefaultParams) { |
| 103 |
// return_type foo(p1, p2 = 0, p3 = 0) |
| 104 |
Builder.AddChunk(CodeCompletionString::CK_Comma); |
| 105 |
Builder.AddTypedTextChunk("p3 = 0"); |
| 106 |
auto *DefaultParam2 = Builder.TakeString(); |
| 107 |
|
| 108 |
Builder.AddChunk(CodeCompletionString::CK_Comma); |
| 109 |
Builder.AddTypedTextChunk("p2 = 0"); |
| 110 |
Builder.AddOptionalChunk(DefaultParam2); |
| 111 |
auto *DefaultParam1 = Builder.TakeString(); |
| 112 |
|
| 113 |
Builder.AddResultTypeChunk("return_type"); |
| 114 |
Builder.AddTypedTextChunk("Foo"); |
| 115 |
Builder.AddChunk(CodeCompletionString::CK_LeftParen); |
| 116 |
Builder.AddPlaceholderChunk("p1"); |
| 117 |
Builder.AddOptionalChunk(DefaultParam1); |
| 118 |
Builder.AddChunk(CodeCompletionString::CK_RightParen); |
| 119 |
|
| 120 |
auto *CCS = Builder.TakeString(); |
| 121 |
computeSignature(*CCS); |
| 122 |
EXPECT_EQ(Signature, "(p1, p2 = 0, p3 = 0)"); |
| 123 |
EXPECT_EQ(Snippet, "(${1:p1})"); |
| 124 |
} |
| 125 |
|
| 126 |
TEST_F(CompletionStringTest, EscapeSnippet) { |
| 127 |
Builder.AddTypedTextChunk("Foo"); |
| 128 |
Builder.AddChunk(CodeCompletionString::CK_LeftParen); |
| 129 |
Builder.AddPlaceholderChunk("$p}1\\"); |
| 130 |
Builder.AddChunk(CodeCompletionString::CK_RightParen); |
| 131 |
|
| 132 |
computeSignature(*Builder.TakeString()); |
| 133 |
EXPECT_EQ(Signature, "($p}1\\)"); |
| 134 |
EXPECT_EQ(Snippet, "(${1:\\$p\\}1\\\\})"); |
| 135 |
} |
| 136 |
|
| 137 |
TEST_F(CompletionStringTest, SnippetsInPatterns) { |
| 138 |
auto MakeCCS = [this]() -> const CodeCompletionString & { |
| 139 |
CodeCompletionBuilder Builder(*Allocator, CCTUInfo); |
| 140 |
Builder.AddTypedTextChunk("namespace"); |
| 141 |
Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); |
| 142 |
Builder.AddPlaceholderChunk("name"); |
| 143 |
Builder.AddChunk(CodeCompletionString::CK_Equal); |
| 144 |
Builder.AddPlaceholderChunk("target"); |
| 145 |
Builder.AddChunk(CodeCompletionString::CK_SemiColon); |
| 146 |
return *Builder.TakeString(); |
| 147 |
}; |
| 148 |
computeSignature(MakeCCS(), /*CompletingPattern=*/false); |
| 149 |
EXPECT_EQ(Snippet, " ${1:name} = ${2:target};"); |
| 150 |
|
| 151 |
// When completing a pattern, the last placeholder holds the cursor position. |
| 152 |
computeSignature(MakeCCS(), /*CompletingPattern=*/true); |
| 153 |
EXPECT_EQ(Snippet, " ${1:name} = $0;"); |
| 154 |
} |
| 155 |
|
| 156 |
TEST_F(CompletionStringTest, IgnoreInformativeQualifier) { |
| 157 |
Builder.AddTypedTextChunk("X"); |
| 158 |
Builder.AddInformativeChunk("info ok"); |
| 159 |
Builder.AddInformativeChunk("info no no::"); |
| 160 |
computeSignature(*Builder.TakeString()); |
| 161 |
EXPECT_EQ(Signature, "info ok"); |
| 162 |
EXPECT_EQ(Snippet, ""); |
| 163 |
} |
| 164 |
|
| 165 |
TEST_F(CompletionStringTest, ObjectiveCMethodNoArguments) { |
| 166 |
Builder.AddResultTypeChunk("void"); |
| 167 |
Builder.AddTypedTextChunk("methodName"); |
| 168 |
|
| 169 |
auto *CCS = Builder.TakeString(); |
| 170 |
computeSignature(*CCS); |
| 171 |
EXPECT_EQ(Signature, ""); |
| 172 |
EXPECT_EQ(Snippet, ""); |
| 173 |
} |
| 174 |
|
| 175 |
TEST_F(CompletionStringTest, ObjectiveCMethodOneArgument) { |
| 176 |
Builder.AddResultTypeChunk("void"); |
| 177 |
Builder.AddTypedTextChunk("methodWithArg:"); |
| 178 |
Builder.AddPlaceholderChunk("(type)"); |
| 179 |
|
| 180 |
auto *CCS = Builder.TakeString(); |
| 181 |
computeSignature(*CCS); |
| 182 |
EXPECT_EQ(Signature, "(type)"); |
| 183 |
EXPECT_EQ(Snippet, "${1:(type)}"); |
| 184 |
} |
| 185 |
|
| 186 |
TEST_F(CompletionStringTest, ObjectiveCMethodTwoArgumentsFromBeginning) { |
| 187 |
Builder.AddResultTypeChunk("int"); |
| 188 |
Builder.AddTypedTextChunk("withFoo:"); |
| 189 |
Builder.AddPlaceholderChunk("(type)"); |
| 190 |
Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); |
| 191 |
Builder.AddTypedTextChunk("bar:"); |
| 192 |
Builder.AddPlaceholderChunk("(type2)"); |
| 193 |
|
| 194 |
auto *CCS = Builder.TakeString(); |
| 195 |
computeSignature(*CCS); |
| 196 |
EXPECT_EQ(Signature, "(type) bar:(type2)"); |
| 197 |
EXPECT_EQ(Snippet, "${1:(type)} bar:${2:(type2)}"); |
| 198 |
} |
| 199 |
|
| 200 |
TEST_F(CompletionStringTest, ObjectiveCMethodTwoArgumentsFromMiddle) { |
| 201 |
Builder.AddResultTypeChunk("int"); |
| 202 |
Builder.AddInformativeChunk("withFoo:"); |
| 203 |
Builder.AddTypedTextChunk("bar:"); |
| 204 |
Builder.AddPlaceholderChunk("(type2)"); |
| 205 |
|
| 206 |
auto *CCS = Builder.TakeString(); |
| 207 |
computeSignature(*CCS); |
| 208 |
EXPECT_EQ(Signature, "(type2)"); |
| 209 |
EXPECT_EQ(Snippet, "${1:(type2)}"); |
| 210 |
} |
| 211 |
|
| 212 |
} // namespace |
| 213 |
} // namespace clangd |
| 214 |
} // namespace clang |