[clangd] Remove Tweak::Intent, use CodeAction kind directly

[sammccall]

Summary

Intent was a nice idea but it ends up being a bit awkward/heavyweight
without adding much.

In particular, it makes it hard to implement CodeActionParams.only properly
(there's an inheritance hierarchy for kinds).

[kbobyrev]

LGTM; maybe mark as refactoring/NFC ;)

clang-tools-extra/clangd/ClangdLSPServer.cpp

 }
 
 /// Transforms a tweak into a code action that would apply it if executed.
 /// EXPECTS: T.prepare() was called and returned true.
 CodeAction toCodeAction(const ClangdServer::TweakRef &T, const URIForFile &File,
                         Range Selection) {
   CodeAction CA;
   CA.title = T.Title;
-  switch (T.Intent) {
-  case Tweak::Refactor:
-    CA.kind = std::string(CodeAction::REFACTOR_KIND);
-    break;
-  case Tweak::Info:
-    CA.kind = std::string(CodeAction::INFO_KIND);
-    break;
-  }
+  CA.kind = T.Kind.str();
   // This tweak may have an expensive second stage, we only run it if the user
   // actually chooses it in the UI. We reply with a command that would run the
   // corresponding tweak.
   // FIXME: for some tweaks, computing the edits is cheap and we could send them
   //        directly.
   CA.command.emplace();
   CA.command->title = T.Title;
   CA.command->command = std::string(Command::CLANGD_APPLY_TWEAK);

clang-tools-extra/clangd/ClangdServer.h

public:
   /// embedders could use this method to get all occurrences of the symbol (e.g.
   /// highlighting them in prepare stage).
   void rename(PathRef File, Position Pos, llvm::StringRef NewName,
               const RenameOptions &Opts, Callback<FileEdits> CB);
 
   struct TweakRef {
     std::string ID;    /// ID to pass for applyTweak.
     std::string Title; /// A single-line message to show in the UI.
-    Tweak::Intent Intent;
+    llvm::StringLiteral Kind;
   };
   /// Enumerate the code tweaks available to the user at a specified point.
   void enumerateTweaks(PathRef File, Range Sel,
                        Callback<std::vector<TweakRef>> CB);
 
   /// Apply the code tweak with a specified \p ID.
   void applyTweak(PathRef File, Range Sel, StringRef ID,
                   Callback<Tweak::Effect> CB);

clang-tools-extra/clangd/ClangdServer.cpp

auto Action = [File = File.str(), Sel, CB = std::move(CB),
     std::vector<TweakRef> Res;
     // Don't allow a tweak to fire more than once across ambiguous selections.
     llvm::DenseSet<llvm::StringRef> PreparedTweaks;
     auto Filter = [&](const Tweak &T) {
       return TweakFilter(T) && !PreparedTweaks.count(T.id());
     };
     for (const auto &Sel : *Selections) {
       for (auto &T : prepareTweaks(*Sel, Filter)) {
-        Res.push_back({T->id(), T->title(), T->intent()});
+        Res.push_back({T->id(), T->title(), T->kind()});
         PreparedTweaks.insert(T->id());
         TweakAvailable.record(1, T->id());
       }
     }
 
     CB(std::move(Res));
   };
 

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

struct Selection {
     unsigned SelectionBegin;
     /// The end offset of the selection
     unsigned SelectionEnd;
     /// The AST nodes that were selected.
     SelectionTree ASTSelection;
     // FIXME: provide a way to get sources and ASTs for other files.
   };
 
-  /// Output of a tweak.
-  enum Intent {
-    /// Apply changes that preserve the behavior of the code.
-    Refactor,
-    /// Provide information to the user.
-    Info,
-  };
   struct Effect {
     /// A message to be displayed to the user.
     llvm::Optional<std::string> ShowMessage;
     FileEdits ApplyEdits;
 
     static Effect showMessage(StringRef S) {
       Effect E;
       E.ShowMessage = std::string(S);
public:
   virtual Expected<Effect> apply(const Selection &Sel) = 0;
 
   /// A one-line title of the action that should be shown to the users in the
   /// UI.
   /// EXPECTS: prepare() was called and returned true.
   virtual std::string title() const = 0;
   /// Describes what kind of action this is.
   /// EXPECTS: prepare() was called and returned true.
-  virtual Intent intent() const = 0;
+  virtual llvm::StringLiteral kind() const = 0;
   /// Is this a 'hidden' tweak, which are off by default.
   virtual bool hidden() const { return false; }
 };
 
 // All tweaks must be registered in the .cpp file next to their definition.
 #define REGISTER_TWEAK(Subclass)                                               \
   ::llvm::Registry<::clang::clangd::Tweak>::Add<Subclass>                      \
       TweakRegistrationFor##Subclass(#Subclass, /*Description=*/"");           \

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

 // symbol.
 class AddUsing : 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;
-  Intent intent() const override { return Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_KIND;
+  }
 
 private:
   // The qualifier to remove. Set by prepare().
   NestedNameSpecifierLoc QualifierToRemove;
   // The name following QualifierToRemove. Set by prepare().
   llvm::StringRef Name;
 };
 REGISTER_TWEAK(AddUsing)

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

 class AnnotateHighlightings : public Tweak {
 public:
   const char *id() const override 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"; }
-  Intent intent() const override { return Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_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

 ///   void foo() { return; }
 ///
 /// a.cc:
 ///
 class DefineInline : public Tweak {
 public:
   const char *id() const override final;
 
-  Intent intent() const override { return Intent::Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_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 {
     const SelectionTree::Node *SelNode = Sel.ASTSelection.commonAncestor();

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

 /// a.cc
 ///   #include "a.h"
 ///   void foo() { return; }
 class DefineOutline : public Tweak {
 public:
   const char *id() const override;
 
   bool hidden() const override { return false; }
-  Intent intent() const override { return Intent::Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_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
     // definition even if we are inside a source file.

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

for (auto N = Inputs.ASTSelection.commonAncestor(); N && !Node;
         Node = N->ASTNode;
     return Node.hasValue();
   }
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override {
     return std::string(
         llvm::formatv("Dump {0} AST", Node->getNodeKind().asStringRef()));
   }
-  Intent intent() const override { return Info; }
+  llvm::StringLiteral kind() const override { return CodeAction::INFO_KIND; }
   bool hidden() const override { return true; }
 
 private:
   static bool dumpable(const ast_type_traits::DynTypedNode &N) {
     // Sadly not all node types can be dumped, and there's no API to check.
     // See DynTypedNode::dump().
     return N.get<Decl>() || N.get<Stmt>() || N.get<Type>();
   }

 public:
   const char *id() const override 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"; }
-  Intent intent() const override { return Info; }
+  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();
 ///      ^^^
Expected<Effect> apply(const Selection &Inputs) override {
 
     for (auto &Sym : getSymbolInfo(
              *Inputs.AST, sourceLocToPosition(Inputs.AST->getSourceManager(),
                                               Inputs.Cursor)))
       Out << Sym;
     return Effect::showMessage(Out.str());
   }
   std::string title() const override { return "Dump symbol under the cursor"; }
-  Intent intent() const override { return Info; }
+  llvm::StringLiteral kind() const override { return CodeAction::INFO_KIND; }
   bool hidden() const override { return true; }
 };
 REGISTER_TWEAK(DumpSymbol)
 
 /// Shows the layout of the RecordDecl under the cursor.
 /// Input:
 /// struct X { int foo; };
 /// ^^^^^^^^
Expected<Effect> apply(const Selection &Inputs) override {
     Inputs.AST->getASTContext().DumpRecordLayout(Record, OS);
     return Effect::showMessage(std::move(OS.str()));
   }
   std::string title() const override {
     return std::string(llvm::formatv(
         "Show {0} layout",
         TypeWithKeyword::getTagTypeKindName(Record->getTagKind())));
   }
-  Intent intent() const override { return Info; }
+  llvm::StringLiteral kind() const override { return CodeAction::INFO_KIND; }
   // FIXME: this is interesting to most users. However:
   //  - triggering is too broad (e.g. triggers on comments within a class)
   //  - showMessage has inconsistent UX (e.g. newlines are stripped in VSCode)
   //  - the output itself is a bit hard to decipher.
   bool hidden() const override { return true; }
 
 private:
   const RecordDecl *Record = nullptr;
 };
 REGISTER_TWEAK(DumpRecordLayout)
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 ///    ^^^^
 /// After:
 ///    MyClass x = Something();
 ///    ^^^^^^^
 /// FIXME: Handle decltype as well
 class ExpandAutoType : public Tweak {
 public:
   const char *id() const final;
-  Intent intent() const override { return Intent::Refactor;}
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_KIND;
+  }
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override;
 
 private:
   /// Cache the AutoTypeLoc, so that we do not need to search twice.
   llvm::Optional<clang::AutoTypeLoc> CachedLocation;
 };

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

 ///   FOO(10*a)
 ///   ^^^
 /// After:
 ///   #define FOO(X) X+X
 ///   10*a+10*a
 class ExpandMacro : public Tweak {
 public:
   const char *id() const override final;
-  Intent intent() const override { return Intent::Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_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;
   std::string MacroName;

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

 }
 
 class ExtractFunction : public Tweak {
 public:
   const char *id() const override final;
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override { return "Extract to function"; }
-  Intent intent() const override { return Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_KIND;
+  }
 
 private:
   ExtractionZone ExtZone;
 };
 
 REGISTER_TWEAK(ExtractFunction)
 tooling::Replacement replaceWithFuncCall(const NewFunction &ExtractedFunc,
                                          const SourceManager &SM,

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

 class ExtractVariable : public Tweak {
 public:
   const char *id() const override final;
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override {
     return "Extract subexpression to variable";
   }
-  Intent intent() const override { return Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_KIND;
+  }
 
 private:
   // the expression to extract
   std::unique_ptr<ExtractionContext> Target;
 };
 REGISTER_TWEAK(ExtractVariable)
 bool ExtractVariable::prepare(const Selection &Inputs) {
   // we don't trigger on empty selections for now

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

 /// Before:
 ///   @"description"
 ///   ^^^
 /// After:
 ///   NSLocalizedString(@"description", @"")
 class ObjCLocalizeStringLiteral : public Tweak {
 public:
   const char *id() const override final;
-  Intent intent() const override { return Intent::Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_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/PopulateSwitch.cpp

 namespace clang {
 namespace clangd {
 namespace {
 class PopulateSwitch : 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"; }
-  Intent intent() const override { return Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_KIND;
+  }
 
 private:
   const DeclContext *DeclCtx = nullptr;
   const SwitchStmt *Switch = nullptr;
   const CompoundStmt *Body = nullptr;
   const EnumType *EnumT = nullptr;
   const EnumDecl *EnumD = nullptr;
 };

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

 /// b)");
 class RawStringLiteral : public Tweak {
 public:
   const char *id() const override final;
 
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override { return "Convert to raw string"; }
-  Intent intent() const override { return Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_KIND;
+  }
 
 private:
   const clang::StringLiteral *Str = nullptr;
 };
 
 REGISTER_TWEAK(RawStringLiteral)
 
 static bool isNormalString(const StringLiteral &Str, SourceLocation Cursor,

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

 /// directives.
 class RemoveUsingNamespace : 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;
-  Intent intent() const override { return Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_KIND;
+  }
 
 private:
   const UsingDirectiveDecl *TargetDirective = nullptr;
 };
 REGISTER_TWEAK(RemoveUsingNamespace)
 
 class FindSameUsings : public RecursiveASTVisitor<FindSameUsings> {
 public:

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

 ///   if (foo) { continue; } else { return 10; }
 class SwapIfBranches : public Tweak {
 public:
   const char *id() const override final;
 
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override { return "Swap if branches"; }
-  Intent intent() const override { return Refactor; }
+  llvm::StringLiteral kind() const override {
+    return CodeAction::REFACTOR_KIND;
+  }
   bool hidden() const override { return true; }
 
 private:
   const IfStmt *If = nullptr;
 };
 
 REGISTER_TWEAK(SwapIfBranches)