[clangd] Add a hidden tweak to annotate all highlighting tokens of the file.

[sammccall]

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

16

it would be nice to use the textmate class name rather than an arbitrary string here, it saves a level of indirection when verifying/debugging behavior

49

These operations are contextual, it would be nice to root at the selected node.

You should be able to do (approximately) this by walking up to the next decl and using it as the traversal scope - don't forget to reset it afterwards!

(This is a bit hacky and invalidates the parent map, but it's a debug tweak so it should be OK)

[hokein]

address comments:

• emit textmate scope names
• rescope to the selected node rather than TU decl.

[sammccall]

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

17

can we move this to SemanticHighlighting.h, and define getTextMateScopeLookupTable() in terms of it? It seems much more fundamental.

54

This needs a comment

60

nit: can you give the overridden traversal scope as narrow a scope as possible? (put it in a block, or just reset explicitly immediately afterwards?) I'm a little paranoid about this scope being reused.

[hokein]

Address comments

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

+//===--- AnnotateHighlightings.cpp -------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+#include "SemanticHighlighting.h"
+#include "refactor/Tweak.h"
+#include "llvm/ADT/ScopeExit.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+// FIXME: move it to SemanticHighlighting.h.
+llvm::StringRef toTextMateScope(HighlightingKind Kind) {
+  static const auto &TextMateLookupTable = getTextMateScopeLookupTable();
+  auto LookupIndex = static_cast<size_t>(Kind);
+  assert(LookupIndex < TextMateLookupTable.size() &&
+         !TextMateLookupTable[LookupIndex].empty());
+  return TextMateLookupTable[LookupIndex].front();
+}
+
+/// 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 {
+public:
+  const char *id() const override final;
+
+  bool prepare(const Selection &Inputs) override {
+    for (auto N = Inputs.ASTSelection.commonAncestor(); N && !InterestedDecl;
+         N = N->Parent)
+      InterestedDecl = N->ASTNode.get<Decl>();
+    return InterestedDecl;
+  }
+  Expected<Effect> apply(const Selection &Inputs) override;
+
+  std::string title() const override { return "Annotate highlighting tokens"; }
+  Intent intent() const override { return Refactor; }
+  bool hidden() const override { return true; }
+
+private:
+  const Decl *InterestedDecl = nullptr;
+};
+REGISTER_TWEAK(AnnotateHighlightings)
+
+Expected<Tweak::Effect> AnnotateHighlightings::apply(const Selection &Inputs) {
+  // Store the existing scopes.
+  const auto &BackupScopes = Inputs.AST.getASTContext().getTraversalScope();
+  // Narrow the traversal scope to the selected node.
+  Inputs.AST.getASTContext().setTraversalScope(
+      {const_cast<Decl *>(InterestedDecl)});
+  auto HighlightingTokens = getSemanticHighlightings(Inputs.AST);
+  // Restore the traversal scope.
+  Inputs.AST.getASTContext().setTraversalScope(BackupScopes);
+
+  auto &SM = Inputs.AST.getSourceManager();
+  tooling::Replacements Result;
+  for (const auto &Token : HighlightingTokens) {
+    assert(Token.R.start.line == Token.R.end.line &&
+           "Token must be at the same line");
+    auto InsertOffset = positionToOffset(Inputs.Code, Token.R.start);
+    if (!InsertOffset)
+      return InsertOffset.takeError();
+
+    auto InsertReplacement = tooling::Replacement(
+        SM.getFileEntryForID(SM.getMainFileID())->getName(), *InsertOffset, 0,
+        ("/* " + toTextMateScope(Token.Kind) + " */").str());
+    if (auto Err = Result.add(InsertReplacement))
+      return std::move(Err);
+  }
+  return Effect::applyEdit(Result);
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

clang-tools-extra/clangd/refactor/tweaks/CMakeLists.txt

 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../..)
 
 set(LLVM_LINK_COMPONENTS
   support
   )
 
 # A target containing all code tweaks (i.e. mini-refactorings) provided by
 # clangd.
 # Built as an object library to make sure the linker does not remove global
 # constructors that register individual tweaks in a global registry.
 # To enable these tweaks in executables or shared libraries, add
 # $<TARGET_OBJECTS:obj.clangDaemonTweaks> to a list of sources, see
 # clangd/tool/CMakeLists.txt for an example.
 add_clang_library(clangDaemonTweaks OBJECT
+  AnnotateHighlightings.cpp
   DumpAST.cpp
   RawStringLiteral.cpp
   SwapIfBranches.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
   clangDaemon
   clangToolingCore
   )

clang-tools-extra/clangd/unittests/TweakTests.cpp

TEST(TweakTest, DumpRecordLayout) {
   checkNotAvailable(ID, "struct ^X;");
   checkNotAvailable(ID, "template <typename T> struct ^X { T t; };");
   checkNotAvailable(ID, "enum ^X {};");
 
   const char *Input = "struct ^X { int x; int y; }";
   EXPECT_THAT(getMessage(ID, Input), ::testing::HasSubstr("0 |   int x"));
 }
 
+TEST(TweakTest, AnnotateHighlightings) {
+  llvm::StringLiteral ID = "AnnotateHighlightings";
+  checkAvailable(ID, "^vo^id^ ^f(^) {^}^"); // available everywhere.
+  const char *Input = "void ^f() {}";
+  const char *Output = "void /* entity.name.function.cpp */f() {}";
+  checkTransform(ID, Input, Output);
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang