[clangd] ClangdServer::codeComplete return CodeCompleteResult, not LSP struct.

[sammccall]

Summary

This provides more structured information that embedders can use for rendering.
ClangdLSPServer continues to call render(), so NFC.

The patch is:

• trivial changes to ClangdServer/ClangdLSPServer
• mostly-mechanical updates to CodeCompleteTests etc for the new API
• new direct tests of render() in CodeCompleteTests
• tiny cleanups to CodeCompletionItem (operator<< and missing initializers)

[ioeric]

lgtm

clangd/ClangdLSPServer.cpp

for (auto &F : getFixes(Params.textDocument.uri.file(), D)) {
       });
     }
   }
   reply(std::move(Commands));
 }
 
 void ClangdLSPServer::onCompletion(TextDocumentPositionParams &Params) {
   Server.codeComplete(Params.textDocument.uri.file(), Params.position, CCOpts,
-                      [](llvm::Expected<CompletionList> List) {
+                      [this](llvm::Expected<CodeCompleteResult> List) {
                         if (!List)
                           return replyError(ErrorCode::InvalidParams,
                                             llvm::toString(List.takeError()));
-                        reply(*List);
+                        CompletionList LSPList;
+                        LSPList.isIncomplete = List->HasMore;
+                        for (const auto &R : List->Completions)
+                          LSPList.items.push_back(R.render(CCOpts));
+                        reply(std::move(LSPList));
                       });
 }
 
 void ClangdLSPServer::onSignatureHelp(TextDocumentPositionParams &Params) {
   Server.signatureHelp(Params.textDocument.uri.file(), Params.position,
                        [](llvm::Expected<SignatureHelp> SignatureHelp) {
                          if (!SignatureHelp)
                            return replyError(

clangd/ClangdServer.h

public:
   ///
   /// This method should only be called for currently tracked files. However, it
   /// is safe to call removeDocument for \p File after this method returns, even
   /// while returned future is not yet ready.
   /// A version of `codeComplete` that runs \p Callback on the processing thread
   /// when codeComplete results become available.
   void codeComplete(PathRef File, Position Pos,
                     const clangd::CodeCompleteOptions &Opts,
-                    Callback<CompletionList> CB);
+                    Callback<CodeCompleteResult> CB);
 
   /// Provide signature help for \p File at \p Pos.  This method should only be
   /// called for tracked files.
   void signatureHelp(PathRef File, Position Pos, Callback<SignatureHelp> CB);
 
   /// Get definition of symbol at a specified \p Line and \p Column in \p File.
   void findDefinitions(PathRef File, Position Pos,
                        Callback<std::vector<Location>> CB);

clangd/ClangdServer.cpp

 
 void ClangdServer::removeDocument(PathRef File) {
   ++InternalVersion[File];
   WorkScheduler.remove(File);
 }
 
 void ClangdServer::codeComplete(PathRef File, Position Pos,
                                 const clangd::CodeCompleteOptions &Opts,
-                                Callback<CompletionList> CB) {
+                                Callback<CodeCompleteResult> CB) {
   // Copy completion options for passing them to async task handler.
   auto CodeCompleteOpts = Opts;
   if (!CodeCompleteOpts.Index) // Respect overridden index.
     CodeCompleteOpts.Index = Index;
 
   // Copy PCHs to avoid accessing this->PCHs concurrently
   std::shared_ptr<PCHContainerOperations> PCHs = this->PCHs;
   auto FS = FSProvider.getFileSystem();
   auto Task = [PCHs, Pos, FS,
-               CodeCompleteOpts](Path File, Callback<CompletionList> CB,
+               CodeCompleteOpts](Path File, Callback<CodeCompleteResult> CB,
                                  llvm::Expected<InputsAndPreamble> IP) {
     if (!IP)
       return CB(IP.takeError());
 
     auto PreambleData = IP->Preamble;
 
     // FIXME(ibiryukov): even if Preamble is non-null, we may want to check
     // both the old and the new version in case only one of them matches.
     CodeCompleteResult Result = clangd::codeComplete(
         File, IP->Command, PreambleData ? &PreambleData->Preamble : nullptr,
         PreambleData ? PreambleData->Inclusions : std::vector<Inclusion>(),
         IP->Contents, Pos, FS, PCHs, CodeCompleteOpts);
-    CompletionList LSPResult;
-    LSPResult.isIncomplete = Result.HasMore;
-    for (const auto &Completion : Result.Completions)
-      LSPResult.items.push_back(Completion.render(CodeCompleteOpts));
-    CB(std::move(LSPResult));
+    CB(std::move(Result));
   };
 
   WorkScheduler.runWithPreamble("CodeComplete", File,
                                 Bind(Task, File.str(), std::move(CB)));
 }
 
 void ClangdServer::signatureHelp(PathRef File, Position Pos,
                                  Callback<SignatureHelp> CB) {

clangd/CodeComplete.h

struct CodeCompletion {
   // This completion item may represent several symbols that can be inserted in
   // the same way, such as function overloads. In this case BundleSize > 1, and
   // the following fields are summaries:
   //  - Signature is e.g. "(...)" for functions.
   //  - SnippetSuffix is similarly e.g. "(${0})".
   //  - ReturnType may be empty
   //  - Documentation may be from one symbol, or a combination of several
   // Other fields should apply equally to all bundled completions.
-  unsigned BundleSize;
+  unsigned BundleSize = 1;
   // The header through which this symbol could be included.
   // Quoted string as expected by an #include directive, e.g. "<memory>".
   // Empty for non-symbol completions, or when not known.
   std::string Header;
   // Present if Header is set and should be inserted to use this item.
   llvm::Optional<TextEdit> HeaderInsertion;
 
   // Scores are used to rank completion items.
struct Scores {
     // e.g. symbols from nearby files have higher relevance.
     float Relevance = 0.f;
   };
   Scores Score;
 
   // Serialize this to an LSP completion item. This is a lossy operation.
   CompletionItem render(const CodeCompleteOptions &) const;
 };
+raw_ostream &operator<<(raw_ostream &, const CodeCompletion &);
 struct CodeCompleteResult {
   std::vector<CodeCompletion> Completions;
   bool HasMore = false;
 };
+raw_ostream &operator<<(raw_ostream &, const CodeCompleteResult &);
 
 /// Get code completions at a specified \p Pos in \p FileName.
 CodeCompleteResult codeComplete(
     PathRef FileName, const tooling::CompileCommand &Command,
     PrecompiledPreamble const *Preamble,
     const std::vector<Inclusion> &PreambleInclusions, StringRef Contents,
     Position Pos, IntrusiveRefCntPtr<vfs::FileSystem> VFS,
     std::shared_ptr<PCHContainerOperations> PCHs, CodeCompleteOptions Opts);

clangd/CodeComplete.cpp

CompletionItem CodeCompletion::render(const CodeCompleteOptions &Opts) const {
   LSP.insertTextFormat = Opts.EnableSnippets ? InsertTextFormat::Snippet
                                              : InsertTextFormat::PlainText;
   if (HeaderInsertion)
     LSP.additionalTextEdits = {*HeaderInsertion};
   LSP.SymbolScope = Scope;
   return LSP;
 }
 
+raw_ostream &operator<<(raw_ostream &OS, const CodeCompletion &C) {
+  // For now just lean on CompletionItem.
+  return OS << C.render(CodeCompleteOptions());
+}
+
+raw_ostream &operator<<(raw_ostream &OS, const CodeCompleteResult &R) {
+  OS << "CodeCompleteResult: " << R.Completions.size() << (R.HasMore ? "+" : "")
+     << " items:\n";
+  for (const auto &C : R.Completions)
+    OS << C << "\n";
+  return OS;
+}
+
 } // namespace clangd
 } // namespace clang

unittests/clangd/ClangdTests.cpp

TEST_F(ClangdVFSTest, InvalidCompileCommand) {
   EXPECT_EQ(runDumpAST(Server, FooCpp), "<no-ast>");
   EXPECT_ERROR(runFindDefinitions(Server, FooCpp, Position()));
   EXPECT_ERROR(runFindDocumentHighlights(Server, FooCpp, Position()));
   EXPECT_ERROR(runRename(Server, FooCpp, Position(), "new_name"));
   // FIXME: codeComplete and signatureHelp should also return errors when they
   // can't parse the file.
   EXPECT_THAT(cantFail(runCodeComplete(Server, FooCpp, Position(),
                                        clangd::CodeCompleteOptions()))
-                  .items,
+                  .Completions,
               IsEmpty());
   auto SigHelp = runSignatureHelp(Server, FooCpp, Position());
   ASSERT_TRUE(bool(SigHelp)) << "signatureHelp returned an error";
   EXPECT_THAT(SigHelp->signatures, IsEmpty());
 }
 
 class ClangdThreadingTest : public ClangdVFSTest {};
 

unittests/clangd/CodeCompleteTests.cpp

 //===-- CodeCompleteTests.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Annotations.h"
 #include "ClangdServer.h"
 #include "CodeComplete.h"
 #include "Compiler.h"
 #include "Matchers.h"
 #include "Protocol.h"
+#include "Quality.h"
 #include "SourceCode.h"
 #include "SyncAPI.h"
 #include "TestFS.h"
 #include "index/MemIndex.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"

 using ::testing::UnorderedElementsAre;
 
 class IgnoreDiagnostics : public DiagnosticsConsumer {
   void onDiagnosticsReady(PathRef File,
                           std::vector<Diag> Diagnostics) override {}
 };
 
 // GMock helpers for matching completion items.
-MATCHER_P(Named, Name, "") { return arg.insertText == Name; }
-MATCHER_P(Scope, Name, "") { return arg.SymbolScope == Name; }
+MATCHER_P(Named, Name, "") { return arg.Name == Name; }
+MATCHER_P(Scope, S, "") { return arg.Scope == S; }
+MATCHER_P(Qualifier, Q, "") { return arg.RequiredQualifier == Q; }
 MATCHER_P(Labeled, Label, "") {
-  std::string Indented;
-  if (!StringRef(Label).startswith(
-          CodeCompleteOptions().IncludeIndicator.Insert) &&
-      !StringRef(Label).startswith(
-          CodeCompleteOptions().IncludeIndicator.NoInsert))
-    Indented =
-        (Twine(CodeCompleteOptions().IncludeIndicator.NoInsert) + Label).str();
-  else
-    Indented = Label;
-  return arg.label == Indented;
+  return arg.RequiredQualifier + arg.Name + arg.Signature == Label;
 }
 MATCHER_P(SigHelpLabeled, Label, "") { return arg.label == Label; }
-MATCHER_P(Kind, K, "") { return arg.kind == K; }
-MATCHER_P(Filter, F, "") { return arg.filterText == F; }
-MATCHER_P(Doc, D, "") { return arg.documentation == D; }
-MATCHER_P(Detail, D, "") { return arg.detail == D; }
+MATCHER_P(Kind, K, "") { return arg.Kind == K; }
+MATCHER_P(Doc, D, "") { return arg.Documentation == D; }
+MATCHER_P(ReturnType, D, "") { return arg.ReturnType == D; }
 MATCHER_P(InsertInclude, IncludeHeader, "") {
-  if (arg.additionalTextEdits.size() != 1)
-    return false;
-  const auto &Edit = arg.additionalTextEdits[0];
-  if (Edit.range.start != Edit.range.end)
-    return false;
-  SmallVector<StringRef, 2> Matches;
-  llvm::Regex RE(R"(#include[ ]*(["<][^">]*[">]))");
-  return RE.match(Edit.newText, &Matches) && Matches[1] == IncludeHeader;
-}
-MATCHER_P(PlainText, Text, "") {
-  return arg.insertTextFormat == clangd::InsertTextFormat::PlainText &&
-         arg.insertText == Text;
-}
-MATCHER_P(Snippet, Text, "") {
-  return arg.insertTextFormat == clangd::InsertTextFormat::Snippet &&
-         arg.insertText == Text;
-}
-MATCHER(NameContainsFilter, "") {
-  if (arg.filterText.empty())
-    return true;
-  return llvm::StringRef(arg.insertText).contains(arg.filterText);
+  return arg.Header == IncludeHeader && bool(arg.HeaderInsertion);
 }
-MATCHER(HasAdditionalEdits, "") { return !arg.additionalTextEdits.empty(); }
+MATCHER(InsertInclude, "") { return bool(arg.HeaderInsertion); }
+MATCHER_P(SnippetSuffix, Text, "") { return arg.SnippetSuffix == Text; }
 
 // Shorthand for Contains(Named(Name)).
-Matcher<const std::vector<CompletionItem> &> Has(std::string Name) {
+Matcher<const std::vector<CodeCompletion> &> Has(std::string Name) {
   return Contains(Named(std::move(Name)));
 }
-Matcher<const std::vector<CompletionItem> &> Has(std::string Name,
+Matcher<const std::vector<CodeCompletion> &> Has(std::string Name,
                                                  CompletionItemKind K) {
   return Contains(AllOf(Named(std::move(Name)), Kind(K)));
 }
-MATCHER(IsDocumented, "") { return !arg.documentation.empty(); }
+MATCHER(IsDocumented, "") { return !arg.Documentation.empty(); }
 
 std::unique_ptr<SymbolIndex> memIndex(std::vector<Symbol> Symbols) {
   SymbolSlab::Builder Slab;
   for (const auto &Sym : Symbols)
     Slab.insert(Sym);
   return MemIndex::build(std::move(Slab).build());
 }
 
-CompletionList completions(ClangdServer &Server, StringRef Text,
+CodeCompleteResult completions(ClangdServer &Server, StringRef Text,
                                std::vector<Symbol> IndexSymbols = {},
                                clangd::CodeCompleteOptions Opts = {}) {
   std::unique_ptr<SymbolIndex> OverrideIndex;
   if (!IndexSymbols.empty()) {
     assert(!Opts.Index && "both Index and IndexSymbols given!");
     OverrideIndex = memIndex(std::move(IndexSymbols));
     Opts.Index = OverrideIndex.get();
   }
 
   auto File = testPath("foo.cpp");
   Annotations Test(Text);
   runAddDocument(Server, File, Test.code());
   auto CompletionList =
       cantFail(runCodeComplete(Server, File, Test.point(), Opts));
-  // Sanity-check that filterText is valid.
-  EXPECT_THAT(CompletionList.items, Each(NameContainsFilter()));
   return CompletionList;
 }
 
 // Builds a server and runs code completion.
 // If IndexSymbols is non-empty, an index will be built and passed to opts.
-CompletionList completions(StringRef Text,
+CodeCompleteResult completions(StringRef Text,
                                std::vector<Symbol> IndexSymbols = {},
                                clangd::CodeCompleteOptions Opts = {}) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
   ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
   return completions(Server, Text, std::move(IndexSymbols), std::move(Opts));
 }
 
 std::string replace(StringRef Haystack, StringRef Needle, StringRef Repl) {
struct ClassWithMembers {
   int AAA();
   int BBB();
   int CCC();
 }
 int main() { ClassWithMembers().^ }
       )cpp",
                              /*IndexSymbols=*/{}, Opts);
 
-  EXPECT_TRUE(Results.isIncomplete);
-  EXPECT_THAT(Results.items, ElementsAre(Named("AAA"), Named("BBB")));
+  EXPECT_TRUE(Results.HasMore);
+  EXPECT_THAT(Results.Completions, ElementsAre(Named("AAA"), Named("BBB")));
 }
 
 TEST(CompletionTest, Filter) {
   std::string Body = R"cpp(
     #define MotorCar
     int Car;
     struct S {
       int FooBar;
       int FooBaz;
       int Qux;
     };
   )cpp";
 
   // Only items matching the fuzzy query are returned.
-  EXPECT_THAT(completions(Body + "int main() { S().Foba^ }").items,
+  EXPECT_THAT(completions(Body + "int main() { S().Foba^ }").Completions,
               AllOf(Has("FooBar"), Has("FooBaz"), Not(Has("Qux"))));
 
   // Macros require  prefix match.
-  EXPECT_THAT(completions(Body + "int main() { C^ }").items,
+  EXPECT_THAT(completions(Body + "int main() { C^ }").Completions,
               AllOf(Has("Car"), Not(Has("MotorCar"))));
 }
 
 void TestAfterDotCompletion(clangd::CodeCompleteOptions Opts) {
   auto Results = completions(
       R"cpp(
       #define MACRO X
 
auto Results = completions(
 
         ClassWithMembers().^
       }
       )cpp",
       {cls("IndexClass"), var("index_var"), func("index_func")}, Opts);
 
   // Class members. The only items that must be present in after-dot
   // completion.
-  EXPECT_THAT(Results.items,
-              AllOf(Has(Opts.EnableSnippets ? "method()" : "method"),
-                    Has("field"), Not(Has("ClassWithMembers")),
+  EXPECT_THAT(Results.Completions,
+              AllOf(Has("method"), Has("field"), Not(Has("ClassWithMembers")),
                     Not(Has("operator=")), Not(Has("~ClassWithMembers"))));
-  EXPECT_IFF(Opts.IncludeIneligibleResults, Results.items,
+  EXPECT_IFF(Opts.IncludeIneligibleResults, Results.Completions,
              Has("private_field"));
   // Global items.
   EXPECT_THAT(
-      Results.items,
+      Results.Completions,
       Not(AnyOf(Has("global_var"), Has("index_var"), Has("global_func"),
                 Has("global_func()"), Has("index_func"), Has("GlobalClass"),
                 Has("IndexClass"), Has("MACRO"), Has("LocalClass"))));
   // There should be no code patterns (aka snippets) in after-dot
   // completion. At least there aren't any we're aware of.
-  EXPECT_THAT(Results.items, Not(Contains(Kind(CompletionItemKind::Snippet))));
+  EXPECT_THAT(Results.Completions,
+              Not(Contains(Kind(CompletionItemKind::Snippet))));
   // Check documentation.
-  EXPECT_IFF(Opts.IncludeComments, Results.items, Contains(IsDocumented()));
+  EXPECT_IFF(Opts.IncludeComments, Results.Completions,
+             Contains(IsDocumented()));
 }
 
 void TestGlobalScopeCompletion(clangd::CodeCompleteOptions Opts) {
   auto Results = completions(
       R"cpp(
       #define MACRO X
 
       int global_var;
auto Results = completions(
         int local_var;
 
         ^
       }
       )cpp",
       {cls("IndexClass"), var("index_var"), func("index_func")}, Opts);
 
   // Class members. Should never be present in global completions.
-  EXPECT_THAT(Results.items,
+  EXPECT_THAT(Results.Completions,
               Not(AnyOf(Has("method"), Has("method()"), Has("field"))));
   // Global items.
-  EXPECT_THAT(Results.items,
-              AllOf(Has("global_var"), Has("index_var"),
-                    Has(Opts.EnableSnippets ? "global_func()" : "global_func"),
+  EXPECT_THAT(Results.Completions,
+              AllOf(Has("global_var"), Has("index_var"), Has("global_func"),
                     Has("index_func" /* our fake symbol doesn't include () */),
                     Has("GlobalClass"), Has("IndexClass")));
   // A macro.
-  EXPECT_IFF(Opts.IncludeMacros, Results.items, Has("MACRO"));
+  EXPECT_IFF(Opts.IncludeMacros, Results.Completions, Has("MACRO"));
   // Local items. Must be present always.
-  EXPECT_THAT(Results.items,
+  EXPECT_THAT(Results.Completions,
               AllOf(Has("local_var"), Has("LocalClass"),
                     Contains(Kind(CompletionItemKind::Snippet))));
   // Check documentation.
-  EXPECT_IFF(Opts.IncludeComments, Results.items, Contains(IsDocumented()));
+  EXPECT_IFF(Opts.IncludeComments, Results.Completions,
+             Contains(IsDocumented()));
 }
 
 TEST(CompletionTest, CompletionOptions) {
   auto Test = [&](const clangd::CodeCompleteOptions &Opts) {
     TestAfterDotCompletion(Opts);
     TestGlobalScopeCompletion(Opts);
   };
   // We used to test every combination of options, but that got too slow (2^N).
   auto Flags = {
       &clangd::CodeCompleteOptions::IncludeMacros,
       &clangd::CodeCompleteOptions::IncludeComments,
-      &clangd::CodeCompleteOptions::EnableSnippets,
       &clangd::CodeCompleteOptions::IncludeCodePatterns,
       &clangd::CodeCompleteOptions::IncludeIneligibleResults,
   };
   // Test default options.
   Test({});
   // Test with one flag flipped.
   for (auto &F : Flags) {
     clangd::CodeCompleteOptions O;
     O.*F ^= true;
     Test(O);
   }
 }
 
 TEST(CompletionTest, Priorities) {
   auto Internal = completions(R"cpp(
       class Foo {
         public: void pub();
         protected: void prot();
         private: void priv();
       };
       void Foo::pub() { this->^ }
   )cpp");
-  EXPECT_THAT(Internal.items,
+  EXPECT_THAT(Internal.Completions,
               HasSubsequence(Named("priv"), Named("prot"), Named("pub")));
 
   auto External = completions(R"cpp(
       class Foo {
         public: void pub();
         protected: void prot();
         private: void priv();
       };
       void test() {
         Foo F;
         F.^
       }
   )cpp");
-  EXPECT_THAT(External.items,
+  EXPECT_THAT(External.Completions,
               AllOf(Has("pub"), Not(Has("prot")), Not(Has("priv"))));
 }
 
 TEST(CompletionTest, Qualifiers) {
   auto Results = completions(R"cpp(
       class Foo {
         public: int foo() const;
         int bar() const;
       };
       class Bar : public Foo {
         int foo() const;
       };
       void test() { Bar().^ }
   )cpp");
-  EXPECT_THAT(Results.items, HasSubsequence(Labeled("bar() const"),
-                                            Labeled("Foo::foo() const")));
-  EXPECT_THAT(Results.items, Not(Contains(Labeled("foo() const")))); // private
+  EXPECT_THAT(Results.Completions,
+              HasSubsequence(AllOf(Qualifier(""), Named("bar")),
+                             AllOf(Qualifier("Foo::"), Named("foo"))));
+  EXPECT_THAT(Results.Completions,
+              Not(Contains(AllOf(Qualifier(""), Named("foo"))))); // private
 }
 
 TEST(CompletionTest, InjectedTypename) {
   // These are suppressed when accessed as a member...
-  EXPECT_THAT(completions("struct X{}; void foo(){ X().^ }").items,
+  EXPECT_THAT(completions("struct X{}; void foo(){ X().^ }").Completions,
               Not(Has("X")));
-  EXPECT_THAT(completions("struct X{ void foo(){ this->^ } };").items,
+  EXPECT_THAT(completions("struct X{ void foo(){ this->^ } };").Completions,
               Not(Has("X")));
   // ...but accessible in other, more useful cases.
-  EXPECT_THAT(completions("struct X{ void foo(){ ^ } };").items, Has("X"));
-  EXPECT_THAT(completions("struct Y{}; struct X:Y{ void foo(){ ^ } };").items,
-              Has("Y"));
+  EXPECT_THAT(completions("struct X{ void foo(){ ^ } };").Completions,
+              Has("X"));
+  EXPECT_THAT(
+      completions("struct Y{}; struct X:Y{ void foo(){ ^ } };").Completions,
   EXPECT_THAT(
       completions(
           "template<class> struct Y{}; struct X:Y<int>{ void foo(){ ^ } };")
-          .items,
+          .Completions,
       Has("Y"));
   // This case is marginal (`using X::X` is useful), we allow it for now.
-  EXPECT_THAT(completions("struct X{}; void foo(){ X::^ }").items, Has("X"));
+  EXPECT_THAT(completions("struct X{}; void foo(){ X::^ }").Completions,
+              Has("X"));
 }
 
 TEST(CompletionTest, Snippets) {
   clangd::CodeCompleteOptions Opts;
-  Opts.EnableSnippets = true;
   auto Results = completions(
       R"cpp(
       struct fake {
         int a;
         int f(int i, const float f) const;
       };
       int main() {
         fake f;
         f.^
       }
       )cpp",
       /*IndexSymbols=*/{}, Opts);
-  EXPECT_THAT(Results.items,
-              HasSubsequence(Snippet("a"),
-                             Snippet("f(${1:int i}, ${2:const float f})")));
+  EXPECT_THAT(
+      Results.Completions,
+      HasSubsequence(Named("a"),
+                     SnippetSuffix("(${1:int i}, ${2:const float f})")));
 }
 
 TEST(CompletionTest, Kinds) {
   auto Results = completions(
       R"cpp(
           #define MACRO X
           int variable;
           struct Struct {};
           int function();
           int X = ^
       )cpp",
       {func("indexFunction"), var("indexVariable"), cls("indexClass")});
-  EXPECT_THAT(Results.items,
+  EXPECT_THAT(Results.Completions,
               AllOf(Has("function", CompletionItemKind::Function),
                     Has("variable", CompletionItemKind::Variable),
                     Has("int", CompletionItemKind::Keyword),
                     Has("Struct", CompletionItemKind::Class),
                     Has("MACRO", CompletionItemKind::Text),
                     Has("indexFunction", CompletionItemKind::Function),
                     Has("indexVariable", CompletionItemKind::Variable),
                     Has("indexClass", CompletionItemKind::Class)));
 
   Results = completions("nam^");
-  EXPECT_THAT(Results.items, Has("namespace", CompletionItemKind::Snippet));
+  EXPECT_THAT(Results.Completions,
+              Has("namespace", CompletionItemKind::Snippet));
 }
 
 TEST(CompletionTest, NoDuplicates) {
   auto Results = completions(
       R"cpp(
           class Adapter {
           };
 
           void f() {
             Adapter^
           }
       )cpp",
       {cls("Adapter")});
 
   // Make sure there are no duplicate entries of 'Adapter'.
-  EXPECT_THAT(Results.items, ElementsAre(Named("Adapter")));
+  EXPECT_THAT(Results.Completions, ElementsAre(Named("Adapter")));
 }
 
 TEST(CompletionTest, ScopedNoIndex) {
   auto Results = completions(
       R"cpp(
           namespace fake { int BigBang, Babble, Box; };
           int main() { fake::ba^ }
       ")cpp");
   // Babble is a better match than BigBang. Box doesn't match at all.
-  EXPECT_THAT(Results.items, ElementsAre(Named("Babble"), Named("BigBang")));
+  EXPECT_THAT(Results.Completions,
+              ElementsAre(Named("Babble"), Named("BigBang")));
 }
 
 TEST(CompletionTest, Scoped) {
   auto Results = completions(
       R"cpp(
           namespace fake { int Babble, Box; };
           int main() { fake::ba^ }
       ")cpp",
       {var("fake::BigBang")});
-  EXPECT_THAT(Results.items, ElementsAre(Named("Babble"), Named("BigBang")));
+  EXPECT_THAT(Results.Completions,
+              ElementsAre(Named("Babble"), Named("BigBang")));
 }
 
 TEST(CompletionTest, ScopedWithFilter) {
   auto Results = completions(
       R"cpp(
           void f() { ns::x^ }
       )cpp",
       {cls("ns::XYZ"), func("ns::foo")});
-  EXPECT_THAT(Results.items,
-              UnorderedElementsAre(AllOf(Named("XYZ"), Filter("XYZ"))));
+  EXPECT_THAT(Results.Completions, UnorderedElementsAre(Named("XYZ")));
 }
 
 TEST(CompletionTest, ReferencesAffectRanking) {
   auto Results = completions("int main() { abs^ }", {ns("absl"), func("abs")});
-  EXPECT_THAT(Results.items, HasSubsequence(Named("abs"), Named("absl")));
+  EXPECT_THAT(Results.Completions, HasSubsequence(Named("abs"), Named("absl")));
   Results = completions("int main() { abs^ }",
                         {withReferences(10000, ns("absl")), func("abs")});
-  EXPECT_THAT(Results.items, HasSubsequence(Named("absl"), Named("abs")));
+  EXPECT_THAT(Results.Completions, HasSubsequence(Named("absl"), Named("abs")));
 }
 
 TEST(CompletionTest, GlobalQualified) {
   auto Results = completions(
       R"cpp(
           void f() { ::^ }
       )cpp",
       {cls("XYZ")});
-  EXPECT_THAT(Results.items, AllOf(Has("XYZ", CompletionItemKind::Class),
-                                   Has("f", CompletionItemKind::Function)));
+  EXPECT_THAT(Results.Completions,
+              AllOf(Has("XYZ", CompletionItemKind::Class),
 }
 
 TEST(CompletionTest, FullyQualified) {
   auto Results = completions(
       R"cpp(
           namespace ns { void bar(); }
           void f() { ::ns::^ }
       )cpp",
       {cls("ns::XYZ")});
-  EXPECT_THAT(Results.items, AllOf(Has("XYZ", CompletionItemKind::Class),
-                                   Has("bar", CompletionItemKind::Function)));
+  EXPECT_THAT(Results.Completions,
+              AllOf(Has("XYZ", CompletionItemKind::Class),
 }
 
 TEST(CompletionTest, SemaIndexMerge) {
   auto Results = completions(
       R"cpp(
           namespace ns { int local; void both(); }
           void f() { ::ns::^ }
       )cpp",
       {func("ns::both"), cls("ns::Index")});
   // We get results from both index and sema, with no duplicates.
   EXPECT_THAT(
-      Results.items,
+      Results.Completions,
       UnorderedElementsAre(Named("local"), Named("Index"), Named("both")));
 }
 
 TEST(CompletionTest, SemaIndexMergeWithLimit) {
   clangd::CodeCompleteOptions Opts;
   Opts.Limit = 1;
   auto Results = completions(
       R"cpp(
           namespace ns { int local; void both(); }
           void f() { ::ns::^ }
       )cpp",
       {func("ns::both"), cls("ns::Index")}, Opts);
-  EXPECT_EQ(Results.items.size(), Opts.Limit);
-  EXPECT_TRUE(Results.isIncomplete);
+  EXPECT_EQ(Results.Completions.size(), Opts.Limit);
+  EXPECT_TRUE(Results.HasMore);
 }
 
 TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   std::string Subdir = testPath("sub");
   std::string SearchDirArg = (llvm::Twine("-I") + Subdir).str();
   CDB.ExtraClangFlags = {SearchDirArg.c_str()};
TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
   Scratch.IncludeHeader = BarURI;
   Sym.Detail = &Scratch;
   // Shoten include path based on search dirctory and insert.
   auto Results = completions(Server,
                              R"cpp(
           int main() { ns::^ }
       )cpp",
                              {Sym});
-  EXPECT_THAT(Results.items,
-              ElementsAre(AllOf(
-                  Named("X"),
-                  Labeled(CodeCompleteOptions().IncludeIndicator.Insert + "X"),
-                  InsertInclude("\"bar.h\""))));
+  EXPECT_THAT(Results.Completions,
+              ElementsAre(AllOf(Named("X"), InsertInclude("\"bar.h\""))));
   // Duplicate based on inclusions in preamble.
   Results = completions(Server,
                         R"cpp(
           #include "sub/bar.h"  // not shortest, so should only match resolved.
           int main() { ns::^ }
       )cpp",
                         {Sym});
-  EXPECT_THAT(Results.items, ElementsAre(AllOf(Named("X"), Labeled("X"),
-                                               Not(HasAdditionalEdits()))));
+  EXPECT_THAT(Results.Completions, ElementsAre(AllOf(Named("X"), Labeled("X"),
+                                                     Not(InsertInclude()))));
 }
 
 TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
 
   IgnoreDiagnostics DiagConsumer;
   ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
auto Results = completions(Server,
                              R"cpp(
           namespace ns {
             class X;
             class Y {}
           }
           int main() { ns::^ }
       )cpp",
                              {SymX, SymY});
-  EXPECT_THAT(Results.items,
-              ElementsAre(AllOf(Named("X"), Not(HasAdditionalEdits())),
-                          AllOf(Named("Y"), Not(HasAdditionalEdits()))));
+  EXPECT_THAT(Results.Completions,
+              ElementsAre(AllOf(Named("X"), Not(InsertInclude())),
+                          AllOf(Named("Y"), Not(InsertInclude()))));
 }
 
 TEST(CompletionTest, IndexSuppressesPreambleCompletions) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
   ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
 
   FS.Files[testPath("bar.h")] =
       R"cpp(namespace ns { struct preamble { int member; }; })cpp";
   auto File = testPath("foo.cpp");
   Annotations Test(R"cpp(
       #include "bar.h"
       namespace ns { int local; }
       void f() { ns::^; }
       void f() { ns::preamble().$2^; }
   )cpp");
   runAddDocument(Server, File, Test.code());
   clangd::CodeCompleteOptions Opts = {};
 
   auto I = memIndex({var("ns::index")});
   Opts.Index = I.get();
   auto WithIndex = cantFail(runCodeComplete(Server, File, Test.point(), Opts));
-  EXPECT_THAT(WithIndex.items,
+  EXPECT_THAT(WithIndex.Completions,
               UnorderedElementsAre(Named("local"), Named("index")));
   auto ClassFromPreamble =
       cantFail(runCodeComplete(Server, File, Test.point("2"), Opts));
-  EXPECT_THAT(ClassFromPreamble.items, Contains(Named("member")));
+  EXPECT_THAT(ClassFromPreamble.Completions, Contains(Named("member")));
 
   Opts.Index = nullptr;
   auto WithoutIndex =
       cantFail(runCodeComplete(Server, File, Test.point(), Opts));
-  EXPECT_THAT(WithoutIndex.items,
+  EXPECT_THAT(WithoutIndex.Completions,
               UnorderedElementsAre(Named("local"), Named("preamble")));
 }
 
 TEST(CompletionTest, DynamicIndexMultiFile) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
   auto Opts = ClangdServer::optsForTest();
Annotations Test(R"cpp(
       }
       void f() { ns::^ }
   )cpp");
   runAddDocument(Server, File, Test.code());
 
   auto Results = cantFail(runCodeComplete(Server, File, Test.point(), {}));
   // "XYZ" and "foo" are not included in the file being completed but are still
   // visible through the index.
-  EXPECT_THAT(Results.items, Has("XYZ", CompletionItemKind::Class));
-  EXPECT_THAT(Results.items, Has("foo", CompletionItemKind::Function));
-  EXPECT_THAT(Results.items, Has("XXX", CompletionItemKind::Class));
-  EXPECT_THAT(Results.items, Contains(AllOf(Named("fooooo"), Filter("fooooo"),
-                                            Kind(CompletionItemKind::Function),
-                                            Doc("Doooc"), Detail("void"))));
+  EXPECT_THAT(Results.Completions, Has("XYZ", CompletionItemKind::Class));
+  EXPECT_THAT(Results.Completions, Has("foo", CompletionItemKind::Function));
+  EXPECT_THAT(Results.Completions, Has("XXX", CompletionItemKind::Class));
+  EXPECT_THAT(Results.Completions,
+              Contains((Named("fooooo"), Kind(CompletionItemKind::Function),
+                        Doc("Doooc"), ReturnType("void"))));
 }
 
 TEST(CompletionTest, Documentation) {
   auto Results = completions(
       R"cpp(
       // Non-doxygen comment.
       int foo();
       /// Doxygen comment.
       /// \param int a
       int bar(int a);
       /* Multi-line
          block comment
       */
       int baz();
 
       int x = ^
      )cpp");
-  EXPECT_THAT(Results.items,
+  EXPECT_THAT(Results.Completions,
               Contains(AllOf(Named("foo"), Doc("Non-doxygen comment."))));
   EXPECT_THAT(
-      Results.items,
+      Results.Completions,
       Contains(AllOf(Named("bar"), Doc("Doxygen comment.\n\\param int a"))));
-  EXPECT_THAT(Results.items,
+  EXPECT_THAT(Results.Completions,
               Contains(AllOf(Named("baz"), Doc("Multi-line\nblock comment"))));
 }
 
 TEST(CompletionTest, GlobalCompletionFiltering) {
 
   Symbol Class = cls("XYZ");
   Class.IsIndexedForCodeCompletion = false;
   Symbol Func = func("XYZ::foooo");
   Func.IsIndexedForCodeCompletion = false;
 
   auto Results = completions(R"(//      void f() {
       XYZ::foooo^
       })",
                              {Class, Func});
-  EXPECT_THAT(Results.items, IsEmpty());
+  EXPECT_THAT(Results.Completions, IsEmpty());
 }
 
 TEST(CodeCompleteTest, DisableTypoCorrection) {
   auto Results = completions(R"cpp(
      namespace clang { int v; }
      void f() { clangd::^
   )cpp");
-  EXPECT_TRUE(Results.items.empty());
+  EXPECT_TRUE(Results.Completions.empty());
 }
 
 TEST(CodeCompleteTest, NoColonColonAtTheEnd) {
   auto Results = completions(R"cpp(
     namespace clang { }
     void f() {
       clan^
     }
   )cpp");
 
-  EXPECT_THAT(Results.items, Contains(Labeled("clang")));
-  EXPECT_THAT(Results.items, Not(Contains(Labeled("clang::"))));
+  EXPECT_THAT(Results.Completions, Contains(Labeled("clang")));
+  EXPECT_THAT(Results.Completions, Not(Contains(Labeled("clang::"))));
 }
 
 TEST(CompletionTest, BacktrackCrashes) {
   // Sema calls code completion callbacks twice in these cases.
   auto Results = completions(R"cpp(
       namespace ns {
       struct FooBarBaz {};
       } // namespace ns
 
      int foo(ns::FooBar^
   )cpp");
 
-  EXPECT_THAT(Results.items, ElementsAre(Labeled("FooBarBaz")));
+  EXPECT_THAT(Results.Completions, ElementsAre(Labeled("FooBarBaz")));
 
   // Check we don't crash in that case too.
   completions(R"cpp(
     struct FooBarBaz {};
     void test() {
       if (FooBarBaz * x^) {}
     }
 )cpp");

 int Y;
 }  // namespace ns
 
 int f(int input_num) {
   F(ns::^)
 }
 )cpp");
 
-  EXPECT_THAT(Results.items,
+  EXPECT_THAT(Results.Completions,
               UnorderedElementsAre(Named("X"), Named("Y")));
 }
 
 TEST(CompletionTest, CompleteInMacroAndNamespaceWithStringification) {
   auto Results = completions(R"cpp(
 void f(const char *, int x);
 #define F(x) f(#x, x)
 
 namespace ns {
 int X;
 
 int f(int input_num) {
   F(^)
 }
 }  // namespace ns
 )cpp");
 
-  EXPECT_THAT(Results.items, Contains(Named("X")));
+  EXPECT_THAT(Results.Completions, Contains(Named("X")));
 }
 
 TEST(CompletionTest, CompleteInExcludedPPBranch) {
   auto Results = completions(R"cpp(
     int bar(int param_in_bar) {
     }
 
     int foo(int param_in_foo) {
 #if 0
   par^
 #endif
     }
 )cpp");
 
-  EXPECT_THAT(Results.items, Contains(Labeled("param_in_foo")));
-  EXPECT_THAT(Results.items, Not(Contains(Labeled("param_in_bar"))));
+  EXPECT_THAT(Results.Completions, Contains(Labeled("param_in_foo")));
+  EXPECT_THAT(Results.Completions, Not(Contains(Labeled("param_in_bar"))));
 }
 
 SignatureHelp signatures(StringRef Text) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
   ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
   auto File = testPath("foo.cpp");
auto Completions = completions(
     struct Foo {
       int SomeNameOfField;
       typedef int SomeNameOfTypedefField;
     };
 
     Foo::^)cpp",
       {func("::SomeNameInTheIndex"), func("::Foo::SomeNameInTheIndex")});
 
-  EXPECT_THAT(Completions.items,
+  EXPECT_THAT(Completions.Completions,
               AllOf(Contains(Labeled("SomeNameOfField")),
                     Contains(Labeled("SomeNameOfTypedefField")),
                     Not(Contains(Labeled("SomeNameInTheIndex")))));
 }
 
 TEST(CompletionTest, NoIndexCompletionsInsideDependentCode) {
   {
     auto Completions = completions(
         R"cpp(
       template <class T>
       void foo() {
         T::^
       }
       )cpp",
         {func("::SomeNameInTheIndex")});
 
-    EXPECT_THAT(Completions.items,
+    EXPECT_THAT(Completions.Completions,
                 Not(Contains(Labeled("SomeNameInTheIndex"))));
   }
 
   {
     auto Completions = completions(
         R"cpp(
       template <class T>
       void foo() {
         T::template Y<int>::^
       }
       )cpp",
         {func("::SomeNameInTheIndex")});
 
-    EXPECT_THAT(Completions.items,
+    EXPECT_THAT(Completions.Completions,
                 Not(Contains(Labeled("SomeNameInTheIndex"))));
   }
 
   {
     auto Completions = completions(
         R"cpp(
       template <class T>
       void foo() {
         T::foo::^
       }
       )cpp",
         {func("::SomeNameInTheIndex")});
 
-    EXPECT_THAT(Completions.items,
+    EXPECT_THAT(Completions.Completions,
                 Not(Contains(Labeled("SomeNameInTheIndex"))));
   }
 }
 
 TEST(CompletionTest, OverloadBundling) {
   clangd::CodeCompleteOptions Opts;
   Opts.BundleOverloads = true;
 
   std::string Context = R"cpp(
     struct X {
       // Overload with int
       int a(int);
       // Overload with bool
       int a(bool);
       int b(float);
     };
     int GFuncC(int);
     int GFuncD(int);
   )cpp";
 
   // Member completions are bundled.
-  EXPECT_THAT(completions(Context + "int y = X().^", {}, Opts).items,
+  EXPECT_THAT(completions(Context + "int y = X().^", {}, Opts).Completions,
               UnorderedElementsAre(Labeled("a(…)"), Labeled("b(float)")));
 
   // Non-member completions are bundled, including index+sema.
   Symbol NoArgsGFunc = func("GFuncC");
   EXPECT_THAT(
-      completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).items,
+      completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
       UnorderedElementsAre(Labeled("GFuncC(…)"), Labeled("GFuncD(int)")));
 
   // Differences in header-to-insert suppress bundling.
   Symbol::Details Detail;
   std::string DeclFile = URI::createFile(testPath("foo")).toString();
   NoArgsGFunc.CanonicalDeclaration.FileURI = DeclFile;
   Detail.IncludeHeader = "<foo>";
   NoArgsGFunc.Detail = &Detail;
   EXPECT_THAT(
-      completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).items,
-      UnorderedElementsAre(
-          AllOf(
-              Named("GFuncC"),
-              Labeled(CodeCompleteOptions().IncludeIndicator.Insert + "GFuncC"),
-              InsertInclude("<foo>")),
+      completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
+      UnorderedElementsAre(AllOf(Named("GFuncC"), InsertInclude("<foo>")),
                            Labeled("GFuncC(int)"), Labeled("GFuncD(int)")));
 
   // Examine a bundled completion in detail.
-  auto A = completions(Context + "int y = X().a^", {}, Opts).items.front();
-  EXPECT_EQ(A.label, " a(…)");
-  EXPECT_EQ(A.detail, "[2 overloads]");
-  EXPECT_EQ(A.insertText, "a");
-  EXPECT_EQ(A.kind, CompletionItemKind::Method);
+  auto A =
+      completions(Context + "int y = X().a^", {}, Opts).Completions.front();
+  EXPECT_EQ(A.Name, "a");
+  EXPECT_EQ(A.Signature, "(…)");
+  EXPECT_EQ(A.BundleSize, 2u);
+  EXPECT_EQ(A.Kind, CompletionItemKind::Method);
+  EXPECT_EQ(A.ReturnType, "int"); // All overloads return int.
   // For now we just return one of the doc strings arbitrarily.
-  EXPECT_THAT(A.documentation, AnyOf(HasSubstr("Overload with int"),
+  EXPECT_THAT(A.Documentation, AnyOf(HasSubstr("Overload with int"),
                                      HasSubstr("Overload with bool")));
-  Opts.EnableSnippets = true;
-  A = completions(Context + "int y = X().a^", {}, Opts).items.front();
-  EXPECT_EQ(A.insertText, "a(${0})");
+  EXPECT_EQ(A.SnippetSuffix, "(${0})");
 }
 
 TEST(CompletionTest, DocumentationFromChangedFileCrash) {
   MockFSProvider FS;
   auto FooH = testPath("foo.h");
   auto FooCpp = testPath("foo.cpp");
   FS.Files[FooH] = R"cpp(
     // this is my documentation comment.
TEST(CompletionTest, DocumentationFromChangedFileCrash) {
 
   // Change the header file. Completion will reuse the old preamble!
   FS.Files[FooH] = R"cpp(
     int func();
   )cpp";
 
   clangd::CodeCompleteOptions Opts;
   Opts.IncludeComments = true;
-  CompletionList Completions =
+  CodeCompleteResult Completions =
       cantFail(runCodeComplete(Server, FooCpp, Source.point(), Opts));
   // We shouldn't crash. Unfortunately, current workaround is to not produce
   // comments for symbols from headers.
-  EXPECT_THAT(Completions.items,
+  EXPECT_THAT(Completions.Completions,
               Contains(AllOf(Not(IsDocumented()), Named("func"))));
 }
 
 TEST(CompletionTest, NonDocComments) {
   MockFSProvider FS;
   auto FooCpp = testPath("foo.cpp");
   FS.Files[FooCpp] = "";
 
Annotations Source(R"cpp(
     int Struct<T>::comments_quux() {
       int a = comments^;
     }
   )cpp");
   // FIXME: Auto-completion in a template requires disabling delayed template
   // parsing.
   CDB.ExtraClangFlags.push_back("-fno-delayed-template-parsing");
   Server.addDocument(FooCpp, Source.code(), WantDiagnostics::Yes);
-  CompletionList Completions = cantFail(runCodeComplete(
+  CodeCompleteResult Completions = cantFail(runCodeComplete(
       Server, FooCpp, Source.point(), clangd::CodeCompleteOptions()));
 
   // We should not get any of those comments in completion.
   EXPECT_THAT(
-      Completions.items,
+      Completions.Completions,
       UnorderedElementsAre(AllOf(Not(IsDocumented()), Named("comments_foo")),
                            AllOf(IsDocumented(), Named("comments_baz")),
                            AllOf(IsDocumented(), Named("comments_quux")),
                            AllOf(Not(IsDocumented()), Named("comments_ns")),
                            // FIXME(ibiryukov): the following items should have
                            // empty documentation, since they are separated from
                            // a comment with an empty line. Unfortunately, I
                            // couldn't make Sema tests pass if we ignore those.

 TEST(CompletionTest, QualifiedNames) {
   auto Results = completions(
       R"cpp(
           namespace ns { int local; void both(); }
           void f() { ::ns::^ }
       )cpp",
       {func("ns::both"), cls("ns::Index")});
   // We get results from both index and sema, with no duplicates.
-  EXPECT_THAT(Results.items, UnorderedElementsAre(Scope("ns::"), Scope("ns::"),
-                                                  Scope("ns::")));
+  EXPECT_THAT(
+      Results.Completions,
+      UnorderedElementsAre(Scope("ns::"), Scope("ns::"), Scope("ns::")));
+}
+
+TEST(CompletionTest, Render) {
+  CodeCompletion C;
+  C.Name = "x";
+  C.Signature = "(bool) const";
+  C.SnippetSuffix = "(${0:bool})";
+  C.ReturnType = "int";
+  C.RequiredQualifier = "Foo::";
+  C.Scope = "ns::Foo::";
+  C.Documentation = "This is x().";
+  C.Header = "\"foo.h\"";
+  C.Kind = CompletionItemKind::Method;
+  C.Score.Total = 1.0;
+
+  CodeCompleteOptions Opts;
+  Opts.IncludeIndicator.Insert = "^";
+  Opts.IncludeIndicator.NoInsert = "";
+  Opts.EnableSnippets = false;
+
+  auto R = C.render(Opts);
+  EXPECT_EQ(R.label, "Foo::x(bool) const");
+  EXPECT_EQ(R.insertText, "Foo::x");
+  EXPECT_EQ(R.insertTextFormat, InsertTextFormat::PlainText);
+  EXPECT_EQ(R.filterText, "x");
+  EXPECT_EQ(R.detail, "int\n\"foo.h\"");
+  EXPECT_EQ(R.documentation, "This is x().");
+  EXPECT_THAT(R.additionalTextEdits, IsEmpty());
+  EXPECT_EQ(R.SymbolScope, "ns::Foo::");
+  EXPECT_EQ(R.sortText, sortText(1.0, "x"));
+
+  Opts.EnableSnippets = true;
+  R = C.render(Opts);
+  EXPECT_EQ(R.insertText, "Foo::x(${0:bool})");
+  EXPECT_EQ(R.insertTextFormat, InsertTextFormat::Snippet);
+
+  C.HeaderInsertion.emplace();
+  R = C.render(Opts);
+  EXPECT_EQ(R.label, "^Foo::x(bool) const");
+  EXPECT_THAT(R.additionalTextEdits, Not(IsEmpty()));
+
+  C.BundleSize = 2;
+  R = C.render(Opts);
+  EXPECT_EQ(R.detail, "[2 overloads]\n\"foo.h\"");
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

unittests/clangd/SyncAPI.h

 
 namespace clang {
 namespace clangd {
 
 // Calls addDocument and then blockUntilIdleForTest.
 void runAddDocument(ClangdServer &Server, PathRef File, StringRef Contents,
                     WantDiagnostics WantDiags = WantDiagnostics::Auto);
 
-llvm::Expected<CompletionList>
+llvm::Expected<CodeCompleteResult>
 runCodeComplete(ClangdServer &Server, PathRef File, Position Pos,
                 clangd::CodeCompleteOptions Opts);
 
 llvm::Expected<SignatureHelp> runSignatureHelp(ClangdServer &Server,
                                                PathRef File, Position Pos);
 
 llvm::Expected<std::vector<Location>>
 runFindDefinitions(ClangdServer &Server, PathRef File, Position Pos);

unittests/clangd/SyncAPI.cpp

private:
   std::future<std::shared_ptr<T>> Future;
 };
 
 template <typename T> CaptureProxy<T> capture(llvm::Optional<T> &Target) {
   return CaptureProxy<T>(Target);
 }
 } // namespace
 
-llvm::Expected<CompletionList>
+llvm::Expected<CodeCompleteResult>
 runCodeComplete(ClangdServer &Server, PathRef File, Position Pos,
                 clangd::CodeCompleteOptions Opts) {
-  llvm::Optional<llvm::Expected<CompletionList>> Result;
+  llvm::Optional<llvm::Expected<CodeCompleteResult>> Result;
   Server.codeComplete(File, Pos, Opts, capture(Result));
   return std::move(*Result);
 }
 
 llvm::Expected<SignatureHelp> runSignatureHelp(ClangdServer &Server,
                                                PathRef File, Position Pos) {
   llvm::Optional<llvm::Expected<SignatureHelp>> Result;
   Server.signatureHelp(File, Pos, capture(Result));