[clangd] use fine-grained code action kinds

[Trass3r]

RFC. First described in https://github.com/clangd/clangd/issues/1326.

[kadircet]

as discussed in https://github.com/clangd/clangd/issues/1326#issuecomment-1313502572, we've decided to not move forward with the change.

clang-tools-extra/clangd/Protocol.h

struct CodeAction {
   /// A short, human-readable, title for this code action.
   std::string title;
 
   /// The kind of the code action.
   /// Used to filter code actions.
   llvm::Optional<std::string> kind;
   const static llvm::StringLiteral QUICKFIX_KIND;
   const static llvm::StringLiteral REFACTOR_KIND;
+  const static llvm::StringLiteral REFACTOR_EXTRACT_KIND;
+  const static llvm::StringLiteral REFACTOR_INLINE_KIND;
+  const static llvm::StringLiteral REFACTOR_MOVE_KIND;
+  const static llvm::StringLiteral REFACTOR_REWRITE_KIND;
+  const static llvm::StringLiteral SOURCE_KIND;
+  const static llvm::StringLiteral SOURCE_ORGANIZE_IMPORTS_KIND;
   const static llvm::StringLiteral INFO_KIND;
 
   /// The diagnostics that this code action resolves.
   llvm::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

clang-tools-extra/clangd/Protocol.cpp

llvm::json::Value toJSON(const Command &C) {
   auto Cmd = llvm::json::Object{{"title", C.title}, {"command", C.command}};
   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::REFACTOR_EXTRACT_KIND = "refactor.extract";
+const llvm::StringLiteral CodeAction::REFACTOR_INLINE_KIND = "refactor.inline";
+const llvm::StringLiteral CodeAction::REFACTOR_MOVE_KIND = "refactor.move";
+const llvm::StringLiteral CodeAction::REFACTOR_REWRITE_KIND = "refactor.rewrite";
+const llvm::StringLiteral CodeAction::SOURCE_KIND = "source";
+const llvm::StringLiteral CodeAction::SOURCE_ORGANIZE_IMPORTS_KIND = "source.organizeImports";
 const llvm::StringLiteral CodeAction::INFO_KIND = "info";
 
 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);

clang-tools-extra/clangd/refactor/InsertionPoint.h

 //===--- InsertionPoint.h - Where should we add new code? --------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_REFACTOR_INSERTIONPOINT_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_REFACTOR_INSERTIONPOINT_H
+
 #include "clang/AST/DeclCXX.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Tooling/Core/Replacement.h"
 
 namespace clang {
 namespace clangd {
 
 // An anchor describes where to insert code into a decl sequence.

 // May insert a new access specifier if needed.
 llvm::Expected<tooling::Replacement> insertDecl(llvm::StringRef Code,
                                                 const CXXRecordDecl &InClass,
                                                 std::vector<Anchor> Anchors,
                                                 AccessSpecifier Protection);
 
 } // namespace clangd
 } // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_REFACTOR_INSERTIONPOINT_H

clang-tools-extra/clangd/refactor/Tweak.h

 
 namespace clang {
 namespace clangd {
 
 class FeatureModuleSet;
 
 /// An interface base for small context-sensitive refactoring actions.
 /// To implement a new tweak use the following pattern in a .cpp file:
-///   class MyTweak : public Tweak {
+///   class MyTweak final : public Tweak {
 ///   public:
 ///     const char* id() const override final; // defined by REGISTER_TWEAK.
 ///     // implement other methods here.
 ///   };
 ///   REGISTER_TWEAK(MyTweak);
 class Tweak {
 public:
   /// Input to prepare and apply tweaks.

clang-tools-extra/clangd/refactor/tweaks/AddUsing.cpp

 // declaration. If we find any existing usings, we insert it there. If not, we
 // insert right after the inner-most relevant namespace declaration. If there is
 // none, or there is, but it was declared via macro, we insert above the first
 // top level decl.
 //
 // Currently this only removes qualifier from under the cursor. In the future,
 // we should improve this to remove qualifier from all occurrences of this
 // symbol.
-class AddUsing : public Tweak {
+class AddUsing final : public Tweak {
 public:
   const char *id() const override;
 
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override;
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_REWRITE_KIND;
   }
 
 private:
   // All of the following are set by prepare().
   // The qualifier to remove.
   NestedNameSpecifierLoc QualifierToRemove;
   // The name following QualifierToRemove.
   llvm::StringRef Name;

clang-tools-extra/clangd/refactor/tweaks/AnnotateHighlightings.cpp

 
 /// Annotate all highlighting tokens in the current file. This is a hidden tweak
 /// which is used to debug semantic highlightings.
 /// Before:
 ///   void f() { int abc; }
 ///   ^^^^^^^^^^^^^^^^^^^^^
 /// After:
 ///   void /* entity.name.function.cpp */ f() { int /* variable.cpp */ abc; }
-class AnnotateHighlightings : public Tweak {
+class AnnotateHighlightings final : public Tweak {
 public:
   const char *id() const final;
 
   bool prepare(const Selection &Inputs) override { return true; }
   Expected<Effect> apply(const Selection &Inputs) override;
 
   std::string title() const override { return "Annotate highlighting tokens"; }
-  llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
-  }
+  llvm::StringLiteral kind() const override { return CodeAction::INFO_KIND; }
   bool hidden() const override { return true; }
 };
 REGISTER_TWEAK(AnnotateHighlightings)
 
 Expected<Tweak::Effect> AnnotateHighlightings::apply(const Selection &Inputs) {
   const Decl *CommonDecl = nullptr;
   for (auto *N = Inputs.ASTSelection.commonAncestor(); N && !CommonDecl;
        N = N->Parent)

clang-tools-extra/clangd/refactor/tweaks/DefineInline.cpp

 ///
 /// ------------------------
 /// After:
 /// a.h:
 ///   void foo() { return; }
 ///
 /// a.cc:
 ///
-class DefineInline : public Tweak {
+class DefineInline final : public Tweak {
 public:
   const char *id() const final;
 
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_MOVE_KIND;
   }
   std::string title() const override {
     return "Move function body to declaration";
   }
 
   // Returns true when selection is on a function definition that does not
   // make use of any internal symbols.
   bool prepare(const Selection &Sel) override {

clang-tools-extra/clangd/refactor/tweaks/DefineOutline.cpp

 /// ----------------
 ///
 /// After:
 /// a.h
 ///   void foo();
 /// a.cc
 ///   #include "a.h"
 ///   void foo() { return; }
-class DefineOutline : public Tweak {
+class DefineOutline final : public Tweak {
 public:
   const char *id() const override;
 
   bool hidden() const override { return false; }
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_MOVE_KIND;
   }
   std::string title() const override {
     return "Move function body to out-of-line";
   }
 
   bool prepare(const Selection &Sel) override {
     // Bail out if we are not in a header file.
     // FIXME: We might want to consider moving method definitions below class

clang-tools-extra/clangd/refactor/tweaks/DumpAST.cpp

 /// Dumps the AST of the selected node.
 /// Input:
 ///   fcall("foo");
 ///   ^^^^^
 /// Message:
 ///   CallExpr
 ///   |-DeclRefExpr fcall
 ///   `-StringLiteral "foo"
-class DumpAST : public Tweak {
+class DumpAST final : public Tweak {
 public:
   const char *id() const final;
 
   bool prepare(const Selection &Inputs) override {
     for (auto *N = Inputs.ASTSelection.commonAncestor(); N && !Node;
          N = N->Parent)
       if (dumpable(N->ASTNode))
         Node = N->ASTNode;

 /// TranslationUnitDecl
 ///   FunctionDecl void foo()
 ///     CompoundStmt {}
 ///      .CallExpr fcall(2 + 2)
 ///        ImplicitCastExpr fcall
 ///         .DeclRefExpr fcall
 ///        BinaryOperator 2 + 2
 ///          *IntegerLiteral 2
-class ShowSelectionTree : public Tweak {
+class ShowSelectionTree final : public Tweak {
 public:
   const char *id() const final;
 
   bool prepare(const Selection &Inputs) override { return true; }
   Expected<Effect> apply(const Selection &Inputs) override {
     return Effect::showMessage(llvm::to_string(Inputs.ASTSelection));
   }
   std::string title() const override { return "Show selection tree"; }
   llvm::StringLiteral kind() const override { return CodeAction::INFO_KIND; }
   bool hidden() const override { return true; }
 };
 REGISTER_TWEAK(ShowSelectionTree)
 
 /// Dumps the symbol under the cursor.
 /// Inputs:
 /// void foo();
 ///      ^^^
 /// Message:
 ///  foo -
 ///  {"containerName":null,"id":"CA2EBE44A1D76D2A","name":"foo","usr":"c:@F@foo#"}
-class DumpSymbol : public Tweak {
+class DumpSymbol final : public Tweak {
   const char *id() const final;
   bool prepare(const Selection &Inputs) override { return true; }
   Expected<Effect> apply(const Selection &Inputs) override {
     std::string Storage;
     llvm::raw_string_ostream Out(Storage);
 
     for (auto &Sym : getSymbolInfo(
              *Inputs.AST, sourceLocToPosition(Inputs.AST->getSourceManager(),

 /// Input:
 /// struct X { int foo; };
 /// ^^^^^^^^
 /// Message:
 ///        0 | struct S
 ///        0 |   int foo
 ///          | [sizeof=4, dsize=4, align=4,
 ///          |  nvsize=4, nvalign=4]
-class DumpRecordLayout : public Tweak {
+class DumpRecordLayout final : public Tweak {
 public:
   const char *id() const final;
 
   bool prepare(const Selection &Inputs) override {
     if (auto *Node = Inputs.ASTSelection.commonAncestor())
       if (auto *D = Node->ASTNode.get<Decl>())
         Record = dyn_cast<RecordDecl>(D);
     return Record && Record->isThisDeclarationADefinition() &&

clang-tools-extra/clangd/refactor/tweaks/ExpandAutoType.cpp

 /// Expand the "auto" type to the derived type
 /// Before:
 ///    auto x = Something();
 ///    ^^^^
 /// After:
 ///    MyClass x = Something();
 ///    ^^^^^^^
 /// FIXME: Handle decltype as well
-class ExpandAutoType : public Tweak {
+class ExpandAutoType final : public Tweak {
 public:
   const char *id() const final;
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_REWRITE_KIND;
   }
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override;
 
 private:
   SourceRange AutoRange;
 };

clang-tools-extra/clangd/refactor/tweaks/ExpandMacro.cpp

 /// Replaces a reference to a macro under the cursor with its expansion.
 /// Before:
 ///   #define FOO(X) X+X
 ///   FOO(10*a)
 ///   ^^^
 /// After:
 ///   #define FOO(X) X+X
 ///   10*a+10*a
-class ExpandMacro : public Tweak {
+class ExpandMacro final : public Tweak {
 public:
   const char *id() const final;
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_REWRITE_KIND;
   }
 
   bool prepare(const Selection &Inputs) override;
   Expected<Tweak::Effect> apply(const Selection &Inputs) override;
   std::string title() const override;
 
 private:
   syntax::TokenBuffer::Expansion Expansion;

clang-tools-extra/clangd/refactor/tweaks/ExtractFunction.cpp

llvm::Expected<NewFunction> getExtractedFunction(ExtractionZone &ExtZone,
   ExtractedFunc.CallerReturnsValue = CapturedInfo.AlwaysReturns;
   if (!createParameters(ExtractedFunc, CapturedInfo) ||
       !generateReturnProperties(ExtractedFunc, *ExtZone.EnclosingFunction,
                                 CapturedInfo))
     return error("Too complex to extract.");
   return ExtractedFunc;
 }
 
-class ExtractFunction : public Tweak {
+class ExtractFunction final : public Tweak {
 public:
   const char *id() const final;
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override { return "Extract to function"; }
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_EXTRACT_KIND;
   }
 
 private:
   ExtractionZone ExtZone;
 };
 
 REGISTER_TWEAK(ExtractFunction)
 tooling::Replacement replaceWithFuncCall(const NewFunction &ExtractedFunc,

clang-tools-extra/clangd/refactor/tweaks/ExtractVariable.cpp

 
 /// Extracts an expression to the variable placeholder
 /// Before:
 /// int x = 5 + 4 * 3;
 ///         ^^^^^
 /// After:
 /// auto placeholder = 5 + 4;
 /// int x = placeholder * 3;
-class ExtractVariable : public Tweak {
+class ExtractVariable final : public Tweak {
 public:
   const char *id() const final;
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override {
     return "Extract subexpression to variable";
   }
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_EXTRACT_KIND;
   }
 
 private:
   // the expression to extract
   std::unique_ptr<ExtractionContext> Target;
 };
 REGISTER_TWEAK(ExtractVariable)
 bool ExtractVariable::prepare(const Selection &Inputs) {

clang-tools-extra/clangd/refactor/tweaks/MemberwiseConstructor.cpp

 // A tweak that adds a C++ constructor which initializes each member.
 //
 // Given:
 //   struct S{ int x; unique_ptr<double> y; };
 // the tweak inserts the constructor:
 //   S(int x, unique_ptr<double> y) : x(x), y(std::move(y)) {}
 //
 // We place the constructor inline, other tweaks are available to outline it.
-class MemberwiseConstructor : public Tweak {
+class MemberwiseConstructor final : public Tweak {
 public:
   const char *id() const final;
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_REWRITE_KIND;
   }
   std::string title() const override {
     return llvm::formatv("Define constructor");
   }
 
   bool prepare(const Selection &Inputs) override {
     // This tweak assumes move semantics.
     if (!Inputs.AST->getLangOpts().CPlusPlus11)

clang-tools-extra/clangd/refactor/tweaks/ObjCLocalizeStringLiteral.cpp

 namespace {
 
 /// Wraps an Objective-C string literal with the NSLocalizedString macro.
 /// Before:
 ///   @"description"
 ///   ^^^
 /// After:
 ///   NSLocalizedString(@"description", @"")
-class ObjCLocalizeStringLiteral : public Tweak {
+class ObjCLocalizeStringLiteral final : public Tweak {
 public:
   const char *id() const final;
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_REWRITE_KIND;
   }
 
   bool prepare(const Selection &Inputs) override;
   Expected<Tweak::Effect> apply(const Selection &Inputs) override;
   std::string title() const override;
 
 private:
   const clang::ObjCStringLiteral *Str = nullptr;

clang-tools-extra/clangd/refactor/tweaks/ObjCMemberwiseInitializer.cpp

return self;
     }
   }
   Stream << "\n\n";
   return Code;
 }
 
 /// Generate an initializer for an Objective-C class based on selected
 /// properties and instance variables.
-class ObjCMemberwiseInitializer : public Tweak {
+class ObjCMemberwiseInitializer final : public Tweak {
 public:
   const char *id() const final;
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_REWRITE_KIND;
   }
 
   bool prepare(const Selection &Inputs) override;
   Expected<Tweak::Effect> apply(const Selection &Inputs) override;
   std::string title() const override;
 
 private:
   SmallVector<MethodParameter, 8>

clang-tools-extra/clangd/refactor/tweaks/PopulateSwitch.cpp

 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include <cassert>
 #include <string>
 
 namespace clang {
 namespace clangd {
 namespace {
-class PopulateSwitch : public Tweak {
+class PopulateSwitch final : public Tweak {
   const char *id() const override;
   bool prepare(const Selection &Sel) override;
   Expected<Effect> apply(const Selection &Sel) override;
   std::string title() const override { return "Populate switch"; }
   llvm::StringLiteral kind() const override {
     return CodeAction::QUICKFIX_KIND;
   }
 

clang-tools-extra/clangd/refactor/tweaks/RawStringLiteral.cpp

 namespace {
 /// Converts a string literal to a raw string.
 /// Before:
 ///   printf("\"a\"\nb");
 ///          ^^^^^^^^^
 /// After:
 ///   printf(R"("a"
 /// b)");
-class RawStringLiteral : public Tweak {
+class RawStringLiteral final : public Tweak {
 public:
   const char *id() const final;
 
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override { return "Convert to raw string"; }
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_REWRITE_KIND;
   }
 
 private:
   const clang::StringLiteral *Str = nullptr;
 };
 
 REGISTER_TWEAK(RawStringLiteral)
 

clang-tools-extra/clangd/refactor/tweaks/RemoveUsingNamespace.cpp

 /// the current file. E.g.,
 ///   using namespace std;
 ///   vector<int> foo(std::map<int, int>);
 /// Would become:
 ///   std::vector<int> foo(std::map<int, int>);
 /// Currently limited to using namespace directives inside global namespace to
 /// simplify implementation. Also the namespace must not contain using
 /// directives.
-class RemoveUsingNamespace : public Tweak {
+class RemoveUsingNamespace final : public Tweak {
 public:
   const char *id() const override;
 
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override {
     return "Remove using namespace, re-qualify names instead";
   }
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_REWRITE_KIND;
   }
 
 private:
   const UsingDirectiveDecl *TargetDirective = nullptr;
 };
 REGISTER_TWEAK(RemoveUsingNamespace)
 
 class FindSameUsings : public RecursiveASTVisitor<FindSameUsings> {

clang-tools-extra/clangd/refactor/tweaks/SpecialMembers.cpp

 //
 // Added members are defaulted or deleted to approximately preserve semantics.
 // (May not be a strict no-op when they were not implicitly declared).
 //
 // Having these spelled out is useful:
 //  - to understand the implicit behavior
 //  - to avoid relying on the implicit behavior
 //  - as a baseline for explicit modification
-class DeclareCopyMove : public Tweak {
+class DeclareCopyMove final : public Tweak {
 public:
   const char *id() const final;
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_REWRITE_KIND;
   }
   std::string title() const override {
     return llvm::formatv("Declare implicit {0} members",
                          NeedCopy ? NeedMove ? "copy/move" : "copy" : "move");
   }
 
   bool prepare(const Selection &Inputs) override {
     // This tweak relies on =default and =delete.

clang-tools-extra/clangd/refactor/tweaks/SwapIfBranches.cpp

 namespace clangd {
 namespace {
 /// Swaps the 'then' and 'else' branch of the if statement.
 /// Before:
 ///   if (foo) { return 10; } else { continue; }
 ///   ^^^^^^^                 ^^^^
 /// After:
 ///   if (foo) { continue; } else { return 10; }
-class SwapIfBranches : public Tweak {
+class SwapIfBranches final : public Tweak {
 public:
   const char *id() const final;
 
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override { return "Swap if branches"; }
   llvm::StringLiteral kind() const override {
-    return CodeAction::REFACTOR_KIND;
+    return CodeAction::REFACTOR_REWRITE_KIND;
   }
   bool hidden() const override { return true; }
 
 private:
   const IfStmt *If = nullptr;
 };
 
 REGISTER_TWEAK(SwapIfBranches)