[clangd] Add a flag for setting isIncomplete flag true in all responses

[kbobyrev]

Summary

To simplify re-ranking the code completion results, some clients might
want to mimic receiving the completion lists which are always incomplete.

[kadircet]

some drive-by comments:

if this is a client-specific option, wouldn't it be equally hard for client to just set this in the LSP layer, instead of telling clangd to do that?

by looking at the current patch, it rather seems like a user-specific option, which will help users who want to prevent their editors from re-ranking results.

clang-tools-extra/clangd/ClangdLSPServer.cpp

983

nit: ClangdServerOpts.AlwaysIncomplete || List->HasMore

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

405

if we want clients to set it wouldn't it be better to make it an initialization option instead?

[kbobyrev]

Address the review comments.

[sammccall]

The idea is this is an easy option for the user to work-around editors that do client-side filtering badly (everyone lets you add flags).
But as mentioned offline, I don't think we actually have an example of an editor this fixes (I think it fixes neither vscode nor coc.nvim). So in that case we shouldn't land it.

[kbobyrev]

Okay, makes sense!

clang-tools-extra/clangd/ClangdLSPServer.cpp

if (!shouldRunCompletion(Params)) {
     return Reply(CompletionList());
   }
   Server->codeComplete(Params.textDocument.uri.file(), Params.position, CCOpts,
                        [Reply = std::move(Reply),
                         this](llvm::Expected<CodeCompleteResult> List) mutable {
                          if (!List)
                            return Reply(List.takeError());
                          CompletionList LSPList;
-                         LSPList.isIncomplete = List->HasMore;
+                         // Set isIncomplete to true regardless of the actual
+                         // results if the corresponding flag was added to
+                         // Clangd invocation.
+                         LSPList.isIncomplete =
+                             ClangdServerOpts.AlwaysIncomplete ? true
+                                                               : List->HasMore;
                          for (const auto &R : List->Completions) {
                            CompletionItem C = R.render(CCOpts);
                            C.kind = adjustKindToCapability(
                                C.kind, SupportedCompletionItemKinds);
                            LSPList.items.push_back(std::move(C));
                          }
                          return Reply(std::move(LSPList));
                        });

clang-tools-extra/clangd/ClangdServer.h

struct Options {
     std::vector<std::string> QueryDriverGlobs;
 
     /// Enable semantic highlighting features.
     bool SemanticHighlighting = false;
 
     /// Enable cross-file rename feature.
     bool CrossFileRename = false;
 
+    /// Always set isIncomplete to true when returning CompletionList.
+    bool AlwaysIncomplete = false;
+
     /// Returns true if the tweak should be enabled.
     std::function<bool(const Tweak &)> TweakFilter = [](const Tweak &T) {
       return !T.hidden(); // only enable non-hidden tweaks.
     };
 
     explicit operator TUScheduler::Options() const;
   };
   // Sensible default options for use in tests.
void symbolInfo(PathRef File, Position Pos,
                   Callback<std::vector<SymbolDetails>> CB);
 
   /// Get semantic ranges around a specified position in a file.
   void semanticRanges(PathRef File, Position Pos,
                       Callback<std::vector<Range>> CB);
 
   /// Get all document links in a file.
   void documentLinks(PathRef File, Callback<std::vector<DocumentLink>> CB);
- 
   /// Returns estimated memory usage for each of the currently open files.
   /// The order of results is unspecified.
   /// Overall memory usage of clangd may be significantly more than reported
   /// here, as this metric does not account (at least) for:
   ///   - memory occupied by static and dynamic index,
   ///   - memory required for in-flight requests,
   /// FIXME: those metrics might be useful too, we should add them.
   std::vector<std::pair<Path, std::size_t>> getUsedBytesPerFile() const;

clang-tools-extra/clangd/test/always-incomplete.test

+# RUN: clangd -lit-test --always-incomplete < %s | FileCheck -strict-whitespace %s
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
+---
+{"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"test:///main.cpp","languageId":"cpp","version":1,"text":"struct S { int a; };\nint main() {\nS().\n}"}}}
+---
+{"jsonrpc":"2.0","id":1,"method":"textDocument/completion","params":{"textDocument":{"uri":"test:///main.cpp"},"position":{"line":2,"character":4}}}
+#      CHECK:  "id": 1
+# CHECK-NEXT:  "jsonrpc": "2.0",
+# CHECK-NEXT:  "result": {
+# CHECK-NEXT:    "isIncomplete": true,
+# CHECK-NEXT:    "items": [
+# CHECK-NEXT:    {
+# CHECK-NEXT:      "detail": "int",
+# CHECK-NEXT:      "filterText": "a",
+# CHECK-NEXT:      "insertText": "a",
+# CHECK-NEXT:      "insertTextFormat": 1,
+# CHECK-NEXT:      "kind": 5,
+# CHECK-NEXT:      "label": " a",
+# CHECK-NEXT:      "score": {{[0-9]+.[0-9]+}},
+# CHECK-NEXT:      "sortText": "{{.*}}a"
+# CHECK-NEXT:      "textEdit": {
+# CHECK-NEXT:        "newText": "a",
+# CHECK-NEXT:        "range": {
+# CHECK-NEXT:          "end": {
+# CHECK-NEXT:            "character": 4,
+# CHECK-NEXT:            "line": 2
+# CHECK-NEXT:          }
+# CHECK-NEXT:          "start": {
+# CHECK-NEXT:            "character": 4,
+# CHECK-NEXT:            "line": 2
+# CHECK-NEXT:          }
+# CHECK-NEXT:        }
+# CHECK-NEXT:      }
+# CHECK-NEXT:    }
+# CHECK-NEXT:  ]
+---
+{"jsonrpc":"2.0","id":4,"method":"shutdown"}
+---
+{"jsonrpc":"2.0","method":"exit"}

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

 
 opt<bool> PrettyPrint{
     "pretty",
     cat(Protocol),
     desc("Pretty-print JSON output"),
     init(false),
 };
 
+opt<bool> AlwaysIncomplete{
+    "always-incomplete",
+    cat(Protocol),
+    desc("Always sets code completion list's isIncomplete to true"),
+    init(false),
+    Hidden,
+};
+
 /// Supports a test URI scheme with relaxed constraints for lit tests.
 /// The path in a test URI will be combined with a platform-specific fake
 /// directory to form an absolute path. For example, test:///a.cpp is resolved
 /// C:\clangd-test\a.cpp on Windows and /clangd-test/a.cpp on Unix.
 class TestScheme : public URIScheme {
 public:
   llvm::Expected<std::string>
   getAbsolutePath(llvm::StringRef /*Authority*/, llvm::StringRef Body,
AsyncIndexLoad = runAsync<void>([Placeholder] {
         Placeholder->reset(std::move(Idx));
     });
     if (Sync)
       AsyncIndexLoad.wait();
   }
   Opts.StaticIndex = StaticIdx.get();
   Opts.AsyncThreadsCount = WorkerThreadsCount;
   Opts.CrossFileRename = CrossFileRename;
+  Opts.AlwaysIncomplete = AlwaysIncomplete;
 
   clangd::CodeCompleteOptions CCOpts;
   CCOpts.IncludeIneligibleResults = IncludeIneligibleResults;
   CCOpts.Limit = LimitResults;
   if (CompletionStyle.getNumOccurrences())
     CCOpts.BundleOverloads = CompletionStyle != Detailed;
   CCOpts.ShowOrigins = ShowOrigins;
   CCOpts.InsertIncludes = HeaderInsertion;