[clangd] Enable completions with fixes in VSCode

[ilya-biryukov]

Summary

When we run completion in VSCode, the following things happen:

• Get get a completion request for a.f^
• clangd returns a completion item with the range a[[.f]], insert text ->foo and filter text foo
• VSCode extracts the word against which we should filter from a range and gets .f
• VSCode tries to match our filter text foo against the word .f and findsno match

As a result, the item we returned gets filtered out and not shown in the UI.

This revision changes the filter text to be .foo and VSCode stops filtering it out.

[ilya-biryukov]

Changing behavior of clangd might affect other clients.
It would be nice to find alternative ways to fix this.

Nevertheless, posting this here as an example of a potential workaround for the problem.

[nridge]

Just throwing a wild idea out there: what if we used textDocument/onTypeFormatting to replace the . with -> as soon as it's typed?

[ilya-biryukov]

In D67224#1804513, @nridge wrote:

Just throwing a wild idea out there: what if we used textDocument/onTypeFormatting to replace the . with -> as soon as it's typed?

There is no way we can do this with proper latency. onTypeFormatting can't wait for the parsing to complete and we need the parsing to complete in order to determine the type of expression to the left of . or ->.
Moreover, in cases like unique_ptr<T>(). we can't know whether the user wants . or -> before we pick the completion item. Both . and -> are allowed in this context.

clang-tools-extra/clangd/CodeComplete.h

struct IncludeCandidate {
     llvm::Optional<TextEdit> Insertion;
   };
   // All possible include headers ranked by preference. By default, the first
   // include is used.
   // If we've bundled together overloads that have different sets of includes,
   // thse includes may not be accurate for all of them.
   llvm::SmallVector<IncludeCandidate, 1> Includes;
 
+  struct FixIt {
+    std::string Before;
+    TextEdit Edit;
+  };
   /// Holds information about small corrections that needs to be done. Like
   /// converting '->' to '.' on member access.
-  std::vector<TextEdit> FixIts;
+  std::vector<FixIt> FixIts;
 
   /// Holds the range of the token we are going to replace with this completion.
   Range CompletionTokenRange;
 
   // Scores are used to rank completion items.
   struct Scores {
     // The score that items are ranked by.
     float Total = 0.f;

clang-tools-extra/clangd/CodeComplete.cpp

if (C.SemaResult) {
       Completion.Kind = toCompletionItemKind(
           C.SemaResult->Kind, C.SemaResult->Declaration, ContextKind);
       // Sema could provide more info on whether the completion was a file or
       // folder.
       if (Completion.Kind == CompletionItemKind::File &&
           Completion.Name.back() == '/')
         Completion.Kind = CompletionItemKind::Folder;
       for (const auto &FixIt : C.SemaResult->FixIts) {
-        Completion.FixIts.push_back(toTextEdit(
-            FixIt, ASTCtx->getSourceManager(), ASTCtx->getLangOpts()));
-      }
-      llvm::sort(Completion.FixIts, [](const TextEdit &X, const TextEdit &Y) {
-        return std::tie(X.range.start.line, X.range.start.character) <
-               std::tie(Y.range.start.line, Y.range.start.character);
+        // FIXME: this should live in SourceCode.h
+        auto &SM = ASTCtx->getSourceManager();
+        CharSourceRange Range = Lexer::makeFileCharRange(FixIt.RemoveRange, SM,
+                                                         ASTCtx->getLangOpts());
+        FileID FID;
+        unsigned StartOffset;
+        std::tie(FID, StartOffset) = SM.getDecomposedLoc(Range.getBegin());
+
+        std::string Code = SM.getBufferData(FID).substr(
+            StartOffset, SM.getFileOffset(Range.getEnd()) - StartOffset);
+
+        Completion.FixIts.push_back(CodeCompletion::FixIt{
+            std::move(Code), toTextEdit(FixIt, ASTCtx->getSourceManager(),
+                                        ASTCtx->getLangOpts())});
+      }
+      llvm::sort(Completion.FixIts, [](const CodeCompletion::FixIt &X,
+                                       const CodeCompletion::FixIt &Y) {
+        return std::tie(X.Edit.range.start.line, X.Edit.range.start.character) <
+               std::tie(Y.Edit.range.start.line, Y.Edit.range.start.character);
       });
       Completion.Deprecated |=
           (C.SemaResult->Availability == CXAvailability_Deprecated);
     }
     if (C.IndexResult) {
       Completion.Origin |= C.IndexResult->Origin;
       if (Completion.Scope.empty())
         Completion.Scope = C.IndexResult->Scope;
CompletionItem CodeCompletion::render(const CodeCompleteOptions &Opts) const {
   // Merge continuous additionalTextEdits into main edit. The main motivation
   // behind this is to help LSP clients, it seems most of them are confused when
   // they are provided with additionalTextEdits that are consecutive to main
   // edit.
   // Note that we store additional text edits from back to front in a line. That
   // is mainly to help LSP clients again, so that changes do not effect each
   // other.
   for (const auto &FixIt : FixIts) {
-    if (isRangeConsecutive(FixIt.range, LSP.textEdit->range)) {
-      LSP.textEdit->newText = FixIt.newText + LSP.textEdit->newText;
-      LSP.textEdit->range.start = FixIt.range.start;
+    if (isRangeConsecutive(FixIt.Edit.range, LSP.textEdit->range)) {
+      LSP.textEdit->newText = FixIt.Edit.newText + LSP.textEdit->newText;
+      LSP.textEdit->range.start = FixIt.Edit.range.start;
+      LSP.filterText = FixIt.Before + LSP.filterText;
     } else {
-      LSP.additionalTextEdits.push_back(FixIt);
+      LSP.additionalTextEdits.push_back(FixIt.Edit);
     }
   }
   if (Opts.EnableSnippets)
     LSP.textEdit->newText += SnippetSuffix;
 
   // FIXME(kadircet): Do not even fill insertText after making sure textEdit is
   // compatible with most of the editors.
   LSP.insertText = LSP.textEdit->newText;

clang-tools-extra/clangd/clients/clangd-vscode/src/extension.ts

logFailedRequest(rpcReply: vscodelc.RPCMessageType, error: any) {
     if (error instanceof vscodelc.ResponseError &&
         rpcReply.method === "workspace/executeCommand")
       vscode.window.showErrorMessage(error.message);
     // Call default implementation.
     super.logFailedRequest(rpcReply, error);
   }
 }
 
+class EnableEditsNearCursorFeature implements vscodelc.StaticFeature {
+  fillClientCapabilities(capabilities: vscodelc.ClientCapabilities): void {
+    const extendedCompletionCapabilities: any = capabilities.textDocument.completion;
+    extendedCompletionCapabilities.editsNearCursor = true;
+  }
+  initialize(capabilities: vscodelc.ServerCapabilities, documentSelector: (string | { language: string; scheme?: string; pattern?: string; } | { language?: string; scheme: string; pattern?: string; } | { language?: string; scheme?: string; pattern: string; })[]): void {
+  }
+}
 /**
  *  this method is called when your extension is activate
  *  your extension is activated the very first time the command is executed
  */
 export function activate(context: vscode.ExtensionContext) {
   const syncFileEvents = getConfig<boolean>('syncFileEvents', true);
 
   const clangd: vscodelc.Executable = {
export function activate(context: vscode.ExtensionContext) {
 
   const clangdClient = new ClangdLanguageClient('Clang Language Server',
                                                 serverOptions, clientOptions);
   const semanticHighlightingFeature =
       new semanticHighlighting.SemanticHighlightingFeature();
   context.subscriptions.push(
       vscode.Disposable.from(semanticHighlightingFeature));
   clangdClient.registerFeature(semanticHighlightingFeature);
+  clangdClient.registerFeature(new EnableEditsNearCursorFeature);
   console.log('Clang Language Server is now active!');
   context.subscriptions.push(clangdClient.start());
   context.subscriptions.push(vscode.commands.registerCommand(
       'clangd-vscode.switchheadersource', async () => {
         const uri =
             vscode.Uri.file(vscode.window.activeTextEditor.document.fileName);
         if (!uri) {
           return;