[clangd] Introduce source.organizeImports code action.

[hokein]

Summary

This would provide us a way to apply unused-includes fixts at once via
the right-click "Source Action" menu or "Organize imports" command
in VSCode.

[hokein]

rebase and polish the implementation.

[kadircet]

clang-tools-extra/clangd/ClangdLSPServer.cpp

992

instead of doing this in here, what about introducing a new "tweak" that'll perform include-cleaner fixes?
Pros are:

• We can use it in places that don't use LSPServer.
• We can later on extend "organize imports" behaviour to do other things if needed.
• Results will be always up-to-date, as we can use the AST and compute the fixes. rather than making use of the "latest" cached version.
• Implementation would be a little bit neater (and contained), as we can just re-use the existing components in IncludeCleaner, rather than doing some ad-hoc matching & retrieval.

WDYT?

1029–1031

what does the UI look like when there are multiple code actions with "organize imports" kind?
e.g. 1&2 can actually be applied together, but 3rd one can't be combined with others, and in theory these can also be triggered on save (if the user opts in). so I am not sure if having multiple code actions, especially when they can't be merged together, really makes much sense on the editor side.

[hokein]

clang-tools-extra/clangd/ClangdLSPServer.cpp

992

I think it is a matter of how we view it (whether it is a fix for all diagnostics or a tweak).

but +1, yeah, this looks like a good idea to me.

1029–1031

what does the UI look like when there are multiple code actions with "organize imports" kind?

Similar to the normal code action, if you trigger it via the right context menu (SourceAction), a window with 3 alternatives will pop up, so that you can select one of them (verified on VSCode).

e.g. 1&2 can actually be applied together, but 3rd one can't be combined with others, and in theory these can also be triggered on save (if the user opts in). so I am not sure if having multiple code actions, especially when they can't be merged together, really makes much sense on the editor side.

Good point. The VSocde codeActionsOnSave behavior is like what you said -- it applies each fix one by one (because we trigger preview window per fix, so 3 preview windows will be triggered in sequence).

I don't see the best way to fix it (from the codeAction requests are identical from the one sent via the context menu), one option is to send only a fixAll codeAction rather than 3.

[kadircet]

resigning in favor of https://reviews.llvm.org/D153769

clang-tools-extra/clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   // Per LSP, codeActionProvider can be either boolean or CodeActionOptions.
   // CodeActionOptions is only valid if the client supports action literal
   // via textDocument.codeAction.codeActionLiteralSupport.
   ServerCaps["codeActionProvider"] =
       Params.capabilities.CodeActionStructure
           ? llvm::json::Object{{"codeActionKinds",
                                 {CodeAction::QUICKFIX_KIND,
                                  CodeAction::REFACTOR_KIND,
-                                 CodeAction::INFO_KIND}}}
+                                 CodeAction::INFO_KIND,
+                                 CodeAction::SOURCE_ORGANIZE_IMPORT}}}
           : llvm::json::Value(true);
 
 
   std::vector<llvm::StringRef> Commands;
   for (llvm::StringRef Command : Handlers.CommandHandlers.keys())
     Commands.push_back(Command);
   llvm::sort(Commands);
   ServerCaps["executeCommandProvider"] =
void ClangdLSPServer::onCodeAction(const CodeActionParams &Params,
   if (KindAllowed(CodeAction::QUICKFIX_KIND)) {
     for (const Diagnostic &D : Params.context.diagnostics) {
       for (auto &F : getFixes(File.file(), D)) {
         FixIts.push_back(toCodeAction(F, Params.textDocument.uri));
         FixIts.back().diagnostics = {D};
       }
     }
   }
+  if (KindAllowed(CodeAction::SOURCE_ORGANIZE_IMPORT)) {
+    std::lock_guard<std::mutex> Lock(FixItsMutex);
+    if (auto FileFixItsIter = FixItsMap.find(File.file());
+        FileFixItsIter != FixItsMap.end()) {
+      std::vector<TextEdit> Edits;
+      for (auto &[Diag, Fixes] : FileFixItsIter->second) {
+        if (Diag.source == "clangd" && Diag.code == "unused-includes")
+          for (auto &F : Fixes)
+            std::copy(F.Edits.begin(), F.Edits.end(),
+                      std::back_inserter(Edits));
+      }
+      if (!Edits.empty()) {
+        FixIts.emplace_back();
+        FixIts.back().title = "remove unusded includes";
+        FixIts.back().kind = std::string(CodeAction::SOURCE_ORGANIZE_IMPORT);
+        FixIts.back().edit.emplace();
+        FixIts.back().edit->changes[File.uri()] = std::move(Edits);
+      }
+    }
+  }
 
   // Now enumerate the semantic code actions.
   auto ConsumeActions =
       [Diags = Params.context.diagnostics, Reply = std::move(Reply), File,
        Selection = Params.range, FixIts = std::move(FixIts), this](
           llvm::Expected<std::vector<ClangdServer::TweakRef>> Tweaks) mutable {
         if (!Tweaks)
           return Reply(Tweaks.takeError());
 
         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.
         CodeAction *OnlyFix = nullptr;
         for (auto &Action : Actions) {
           if (Action.kind && *Action.kind == CodeAction::QUICKFIX_KIND) {
             if (OnlyFix) {
               OnlyFix = nullptr;
               break;
             }
             OnlyFix = &Action;
           }
         }
         if (OnlyFix) {
           OnlyFix->isPreferred = true;

clang-tools-extra/clangd/Protocol.h

struct CodeAction {
   std::string title;
 
   /// The kind of the code action.
   /// Used to filter code actions.
   std::optional<std::string> kind;
   const static llvm::StringLiteral QUICKFIX_KIND;
   const static llvm::StringLiteral REFACTOR_KIND;
   const static llvm::StringLiteral INFO_KIND;
+  const static llvm::StringLiteral SOURCE_ORGANIZE_IMPORT;
 
   /// The diagnostics that this code action resolves.
   std::optional<std::vector<Diagnostic>> diagnostics;
 
   /// Marks this as a preferred action. Preferred actions are used by the
   /// `auto fix` command and can be targeted by keybindings.
   /// A quick fix should be marked preferred if it properly addresses the
   /// underlying error. A refactoring should be marked preferred if it is the

clang-tools-extra/clangd/Protocol.cpp

llvm::json::Value toJSON(const Command &C) {
   if (!C.argument.getAsNull())
     Cmd["arguments"] = llvm::json::Array{C.argument};
   return std::move(Cmd);
 }
 
 const llvm::StringLiteral CodeAction::QUICKFIX_KIND = "quickfix";
 const llvm::StringLiteral CodeAction::REFACTOR_KIND = "refactor";
 const llvm::StringLiteral CodeAction::INFO_KIND = "info";
+const llvm::StringLiteral CodeAction::SOURCE_ORGANIZE_IMPORT = "source.organizeImports";
 
 llvm::json::Value toJSON(const CodeAction &CA) {
   auto CodeAction = llvm::json::Object{{"title", CA.title}};
   if (CA.kind)
     CodeAction["kind"] = *CA.kind;
   if (CA.diagnostics)
     CodeAction["diagnostics"] = llvm::json::Array(*CA.diagnostics);
   if (CA.isPreferred)