[clangd] Set Incompleteness for spec fuzzyfind requests

[dgoldman]

clang-tools-extra/clangd/CodeComplete.cpp

1728

Can this be safely moved - looks like it wasn't before?

[dgoldman]

clang-tools-extra/clangd/CodeComplete.cpp

1728

Ah nevermind, missed that this is moving the local copy.

clang-tools-extra/clangd/CodeComplete.h

 #include "support/Path.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/CodeCompleteOptions.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <functional>
 #include <future>
+#include <utility>
 
 namespace clang {
 class NamedDecl;
 namespace clangd {
 struct PreambleData;
 struct CodeCompletion;
 
 struct CodeCompleteOptions {
struct SpeculativeFuzzyFind {
   /// A cached request from past code completions.
   /// Set by caller of `codeComplete()`.
   llvm::Optional<FuzzyFindRequest> CachedReq;
   /// The actual request used by `codeComplete()`.
   /// Set by `codeComplete()`. This can be used by callers to update cache.
   llvm::Optional<FuzzyFindRequest> NewReq;
   /// The result is consumed by `codeComplete()` if speculation succeeded.
   /// NOTE: the destructor will wait for the async call to finish.
-  std::future<SymbolSlab> Result;
+  std::future<std::pair<bool /*Incomplete*/, SymbolSlab>> Result;
 };
 
 /// Gets code completions at a specified \p Pos in \p FileName.
 ///
 /// If \p Preamble is nullptr, this runs code completion without compiling the
 /// code.
 ///
 /// If \p SpecFuzzyFind is set, a speculative and asynchronous fuzzy find index

clang-tools-extra/clangd/CodeComplete.cpp

 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <algorithm>
 #include <iterator>
 #include <limits>
+#include <utility>
 
 // We log detailed candidate here if you run with -debug-only=codecomplete.
 #define DEBUG_TYPE "CodeComplete"
 
 namespace clang {
 namespace clangd {
 namespace {
 
if (Sym.SymInfo.Kind == index::SymbolKind::Protocol &&
       Sym.SymInfo.Lang == index::SymbolLanguage::ObjC)
     return Kind == CodeCompletionContext::CCC_ObjCProtocolName;
   else if (Kind == CodeCompletionContext::CCC_ObjCProtocolName)
     // Don't show anything else in ObjC protocol completions.
     return false;
   return true;
 }
 
-std::future<SymbolSlab> startAsyncFuzzyFind(const SymbolIndex &Index,
-                                            const FuzzyFindRequest &Req) {
-  return runAsync<SymbolSlab>([&Index, Req]() {
+std::future<std::pair<bool, SymbolSlab>>
+startAsyncFuzzyFind(const SymbolIndex &Index, const FuzzyFindRequest &Req) {
+  return runAsync<std::pair<bool, SymbolSlab>>([&Index, Req]() {
     trace::Span Tracer("Async fuzzyFind");
     SymbolSlab::Builder Syms;
+    bool Incomplete =
         Index.fuzzyFind(Req, [&Syms](const Symbol &Sym) { Syms.insert(Sym); });
-    return std::move(Syms).build();
+    return std::make_pair(Incomplete, std::move(Syms).build());
   });
 }
 
 // Creates a `FuzzyFindRequest` based on the cached index request from the
 // last completion, if any, and the speculated completion filter text in the
 // source code.
 FuzzyFindRequest speculativeFuzzyFindRequestForCompletion(
     FuzzyFindRequest CachedReq, const CompletionPrefix &HeuristicPrefix) {
SymbolSlab queryIndex() {
     if (SpecFuzzyFind)
       SpecFuzzyFind->NewReq = Req;
     if (SpecFuzzyFind && SpecFuzzyFind->Result.valid() && (*SpecReq == Req)) {
       vlog("Code complete: speculative fuzzy request matches the actual index "
            "request. Waiting for the speculative index results.");
       SPAN_ATTACH(Tracer, "Speculative results", true);
 
       trace::Span WaitSpec("Wait speculative results");
-      return SpecFuzzyFind->Result.get();
+      auto SpecRes = SpecFuzzyFind->Result.get();
+      Incomplete |= SpecRes.first;
+      return std::move(SpecRes.second);
     }
 
     SPAN_ATTACH(Tracer, "Speculative results", false);
 
     // Run the query against the index.
     SymbolSlab::Builder ResultsBuilder;
     Incomplete |= Opts.Index->fuzzyFind(
         Req, [&](const Symbol &Sym) { ResultsBuilder.insert(Sym); });

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

TEST(CompletionTest, EnableSpeculativeIndexRequest) {
   )cpp");
   runAddDocument(Server, File, Test.code());
   clangd::CodeCompleteOptions Opts = {};
 
   IndexRequestCollector Requests;
   Opts.Index = &Requests;
 
   auto CompleteAtPoint = [&](StringRef P) {
-    cantFail(runCodeComplete(Server, File, Test.point(P), Opts));
+    auto CCR = cantFail(runCodeComplete(Server, File, Test.point(P), Opts));
+    EXPECT_TRUE(CCR.HasMore);
   };
 
   CompleteAtPoint("1");
   auto Reqs1 = Requests.consumeRequests(1);
   ASSERT_EQ(Reqs1.size(), 1u);
   EXPECT_THAT(Reqs1[0].Scopes, UnorderedElementsAre("ns1::"));
 
   CompleteAtPoint("2");