[clangd] Respect codeAction.isPreferredSupport in client capabilities

[kadircet]

Summary

Fixes https://github.com/clangd/clangd/issues/573.

[sammccall]

Hang on - why do we need to do this?

In general we don't do client feature detection for every piece of functionality we have, only when it causes us to behave incompatibly.
And again in general we assume that setting extra properties on JSON objects is compatible. (e.g. score extensions on code completion).

[sammccall]

I hadn't seen the bug, will ask here what the problem is.

clang-tools-extra/clangd/ClangdLSPServer.h

private:
   /// Options used for diagnostics.
   ClangdDiagnosticOptions DiagOpts;
   /// The supported kinds of the client.
   SymbolKindBitset SupportedSymbolKinds;
   /// The supported completion item kinds of the client.
   CompletionItemKindBitset SupportedCompletionItemKinds;
   /// Whether the client supports CodeAction response objects.
   bool SupportsCodeAction = false;
+  /// Whether the client supports isPreferred property on CodeAction response
+  /// objects.
+  bool SupportsCodeActionIsPreferred = false;
   /// From capabilities of textDocument/documentSymbol.
   bool SupportsHierarchicalDocumentSymbol = false;
   /// Whether the client supports showing file status.
   bool SupportFileStatus = false;
   /// Which kind of markup should we use in textDocument/hover responses.
   MarkupKind HoverContentFormat = MarkupKind::PlainText;
   /// Whether the client supports offsets for parameter info labels.
   bool SupportsOffsetsInSignatureHelp = false;

clang-tools-extra/clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   DiagOpts.SendDiagnosticCategory = Params.capabilities.DiagnosticCategory;
   DiagOpts.EmitRelatedLocations =
       Params.capabilities.DiagnosticRelatedInformation;
   if (Params.capabilities.WorkspaceSymbolKinds)
     SupportedSymbolKinds |= *Params.capabilities.WorkspaceSymbolKinds;
   if (Params.capabilities.CompletionItemKinds)
     SupportedCompletionItemKinds |= *Params.capabilities.CompletionItemKinds;
   SupportsCodeAction = Params.capabilities.CodeActionStructure;
+  SupportsCodeActionIsPreferred = Params.capabilities.CodeActionIsPreferred;
   SupportsHierarchicalDocumentSymbol =
       Params.capabilities.HierarchicalDocumentSymbol;
   SupportFileStatus = Params.initializationOptions.FileStatus;
   HoverContentFormat = Params.capabilities.HoverContentFormat;
   SupportsOffsetsInSignatureHelp = Params.capabilities.OffsetsInSignatureHelp;
   if (Params.capabilities.WorkDoneProgress)
     BackgroundIndexProgressState = BackgroundIndexProgress::Empty;
   BackgroundIndexSkipCreate = Params.capabilities.ImplicitProgressCreation;
auto ConsumeActions =
 
         std::vector<CodeAction> Actions = std::move(FixIts);
         Actions.reserve(Actions.size() + Tweaks->size());
         for (const auto &T : *Tweaks)
           Actions.push_back(toCodeAction(T, File, Selection));
 
         // If there's exactly one quick-fix, call it "preferred".
         // We never consider refactorings etc as preferred.
+        if (SupportsCodeActionIsPreferred) {
           CodeAction *OnlyFix = nullptr;
           for (auto &Action : Actions) {
             if (Action.kind && *Action.kind == CodeAction::QUICKFIX_KIND) {
               if (OnlyFix) {
                 OnlyFix->isPreferred = false;
                 break;
               }
               Action.isPreferred = true;
               OnlyFix = &Action;
             }
           }
+        }
 
         if (SupportsCodeAction)
           return Reply(llvm::json::Array(Actions));
         std::vector<Command> Commands;
         for (const auto &Action : Actions) {
           if (auto Command = asCommand(Action))
             Commands.push_back(std::move(*Command));
         }

clang-tools-extra/clangd/Protocol.h

struct ClientCapabilities {
   /// The documentation format that should be used for textDocument/completion.
   /// textDocument.completion.completionItem.documentationFormat
   MarkupKind CompletionDocumentationFormat = MarkupKind::PlainText;
 
   /// Client supports CodeAction return value for textDocument/codeAction.
   /// textDocument.codeAction.codeActionLiteralSupport.
   bool CodeActionStructure = false;
 
+  /// Client supports isPreferred property on CodeActions.
+  /// textDocument.codeAction.isPreferredSupport.
+  bool CodeActionIsPreferred = false;
+
   /// Client advertises support for the semanticTokens feature.
   /// We support the textDocument/semanticTokens request in any case.
   /// textDocument.semanticTokens
   bool SemanticTokens = false;
   /// Client supports Theia semantic highlighting extension.
   /// https://github.com/microsoft/vscode-languageserver-node/pull/367
   /// This will be ignored if the client also supports semanticTokens.
   /// textDocument.semanticHighlightingCapabilities.semanticHighlighting

clang-tools-extra/clangd/Protocol.cpp

if (auto *Completion = TextDocument->getObject("completion")) {
         }
       }
       if (auto EditsNearCursor = Completion->getBoolean("editsNearCursor"))
         R.CompletionFixes = *EditsNearCursor;
     }
     if (auto *CodeAction = TextDocument->getObject("codeAction")) {
       if (CodeAction->getObject("codeActionLiteralSupport"))
         R.CodeActionStructure = true;
+      if (auto IsPreferred = CodeAction->getBoolean("isPreferredSupport"))
+        R.CodeActionIsPreferred = *IsPreferred;
     }
     if (auto *DocumentSymbol = TextDocument->getObject("documentSymbol")) {
       if (auto HierarchicalSupport =
               DocumentSymbol->getBoolean("hierarchicalDocumentSymbolSupport"))
         R.HierarchicalDocumentSymbol = *HierarchicalSupport;
     }
     if (auto *Hover = TextDocument->getObject("hover")) {
       if (auto *ContentFormat = Hover->getArray("contentFormat")) {