[clangd] Limit completion results.

[hokein]

Summary

• truncate symbols from static/dynamic index to the limited number

(which would save lots of cost in constructing the merged symbols).

• add an CLI option allowing to limit the number of returned completion results.

(default to 100)

[sammccall]

Thank you!

clangd/tool/ClangdMain.cpp

128 ↗

(On Diff #131271)

nit: our flag names are generally too long, I think. is completion-limit enough?

131 ↗

(On Diff #131271)

I think we probably want to keep the default at 0 for now. I'm fine with 100 personally, but talk to Ilya if you want to change the default :-)

This shouldn't be hidden.

224 ↗

(On Diff #131271)

nit: whitespace

unittests/clangd/CodeCompleteTests.cpp

541 ↗

(On Diff #131271)

also assert Results.isIncomplete

[hokein]

Address review comments.

clangd/tool/ClangdMain.cpp

131 ↗

(On Diff #131271)

Let's keep the original behavior at the moment.

clang-tools-extra/trunk/clangd/CodeComplete.cpp

private:
   }
 
   SymbolSlab queryIndex() {
     if (!Opts.Index || !allowIndex(Recorder.CCContext.getKind()))
       return SymbolSlab();
     SymbolSlab::Builder ResultsBuilder;
     // Build the query.
     FuzzyFindRequest Req;
+    if (Opts.Limit)
+      Req.MaxCandidateCount = Opts.Limit;
     Req.Query = Filter->pattern();
     Req.Scopes =
         getQueryScopes(Recorder.CCContext, Recorder.CCSema->getSourceManager());
     log(Ctx, llvm::formatv(
                  "Code complete: fuzzyFind(\"{0}\", Scopes: [{1}]", Req.Query,
                  llvm::join(Req.Scopes.begin(), Req.Scopes.end(), ",")));
     // Run the query against the index.
     Incomplete |= !Opts.Index->fuzzyFind(

clang-tools-extra/trunk/clangd/index/Merge.cpp

More |= Static->fuzzyFind(Ctx, Req, [&](const Symbol &S) {
        if (DynS == Dyn.end())
          return Callback(S);
        SeenDynamicSymbols.insert(S.ID);
        Callback(mergeSymbol(*DynS, S, &Scratch));
      });
      for (const Symbol &S : Dyn)
        if (!SeenDynamicSymbols.count(S.ID))
          Callback(S);
-     return More;
+     return !More; // returning true indicates the result is complete.
   }
 
 private:
   const SymbolIndex *Dynamic, *Static;
 };
 }
 
 Symbol

clang-tools-extra/trunk/clangd/tool/ClangdMain.cpp

static llvm::cl::opt<PCHStorageFlag> PCHStorage(
     "pch-storage",
     llvm::cl::desc("Storing PCHs in memory increases memory usages, but may "
                    "improve performance"),
     llvm::cl::values(
         clEnumValN(PCHStorageFlag::Disk, "disk", "store PCHs on disk"),
         clEnumValN(PCHStorageFlag::Memory, "memory", "store PCHs in memory")),
     llvm::cl::init(PCHStorageFlag::Disk));
 
+static llvm::cl::opt<int> LimitCompletionResult(
+    "limit-completion",
+    llvm::cl::desc("Limit the number of completion results returned by clangd. "
+                   "0 means no limit."),
+    llvm::cl::init(0));
+
 static llvm::cl::opt<bool> RunSynchronously(
     "run-synchronously",
     llvm::cl::desc("Parse on main thread. If set, -j is ignored"),
     llvm::cl::init(false), llvm::cl::Hidden);
 
 static llvm::cl::opt<Path>
     ResourceDir("resource-dir",
                 llvm::cl::desc("Directory for system clang headers"),
int main(int argc, char *argv[]) {
   llvm::sys::ChangeStdinToBinary();
 
   std::unique_ptr<SymbolIndex> StaticIdx;
   if (EnableIndexBasedCompletion && !YamlSymbolFile.empty())
     StaticIdx = BuildStaticIndex(YamlSymbolFile);
   clangd::CodeCompleteOptions CCOpts;
   CCOpts.EnableSnippets = EnableSnippets;
   CCOpts.IncludeIneligibleResults = IncludeIneligibleResults;
+  CCOpts.Limit = LimitCompletionResult;
   // Initialize and run ClangdLSPServer.
   ClangdLSPServer LSPServer(Out, WorkerThreadsCount, StorePreamblesInMemory,
                             CCOpts, ResourceDirRef, CompileCommandsDirPath,
                             EnableIndexBasedCompletion, StaticIdx.get());
   constexpr int NoShutdownRequestErrorCode = 1;
   llvm::set_thread_name("clangd.main");
   return LSPServer.run(std::cin) ? 0 : NoShutdownRequestErrorCode;
 }

clang-tools-extra/trunk/unittests/clangd/CodeCompleteTests.cpp

auto Results = completions(
       )cpp",
       {func("ns::both"), cls("ns::Index")});
   // We get results from both index and sema, with no duplicates.
   EXPECT_THAT(
       Results.items,
       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);
+}
+
 TEST(CompletionTest, IndexSuppressesPreambleCompletions) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
   ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
                       /*StorePreamblesInMemory=*/true);
 
   FS.Files[getVirtualTestFilePath("bar.h")] =