[clangd] Some tweaks on semantic highlighting lookuptable.

[hokein]

Summary

• move toTextMateScope to SemanticHighlighting.h;
• move the buildLookupTable to LSP layer (as LSP requires such form);

[sammccall]

clang-tools-extra/clangd/ClangdLSPServer.cpp

87

while here, can we have "highlight" in the name? like "buildHighlightScopeLookupTable"?

clang-tools-extra/clangd/SemanticHighlighting.cpp

159

use case Last instead of default for better warnings.
https://llvm.org/docs/CodingStandards.html#don-t-use-default-labels-in-fully-covered-switches-over-enumerations

clang-tools-extra/clangd/SemanticHighlighting.h

30

the name is a little confusing as it's last-plus-one. NumKinds is a common idiom I think.

[hokein]

Address comments.

clang-tools-extra/clangd/ClangdLSPServer.cpp

 CompletionItemKindBitset defaultCompletionItemKinds() {
   CompletionItemKindBitset Defaults;
   for (size_t I = CompletionItemKindMin;
        I <= static_cast<size_t>(CompletionItemKind::Reference); ++I)
     Defaults.set(I);
   return Defaults;
 }
 
+// Build a lookup table (HighlightingKind => {TextMate Scopes}), which is sent
+// to the LSP client.
+std::vector<std::vector<std::string>> buildHighlightScopeLookupTable() {
+  std::vector<std::vector<std::string>> LookupTable;
+  // HighlightingKind is using as the index.
+  for (int KindValue = 0; KindValue < (int)HighlightingKind::NumKinds;
+       ++KindValue)
+    LookupTable.push_back({toTextMateScope((HighlightingKind)(KindValue))});
+  return LookupTable;
+}
+
 } // namespace
 
 // MessageHandler dispatches incoming LSP messages.
 // It handles cross-cutting concerns:
 //  - serializes/deserializes protocol objects to JSON
 //  - logging of inbound messages
 //  - cancellation handling
 //  - basic call tracing
llvm::json::Object Result{
             {"typeHierarchyProvider", true},
         }}}};
   if (NegotiatedOffsetEncoding)
     Result["offsetEncoding"] = *NegotiatedOffsetEncoding;
   if (Params.capabilities.SemanticHighlighting)
     Result.getObject("capabilities")
         ->insert(
             {"semanticHighlighting",
-             llvm::json::Object{{"scopes", getTextMateScopeLookupTable()}}});
+             llvm::json::Object{{"scopes", buildHighlightScopeLookupTable()}}});
   Reply(std::move(Result));
 }
 
 void ClangdLSPServer::onShutdown(const ShutdownParams &Params,
                                  Callback<std::nullptr_t> Reply) {
   // Do essentially nothing, just say we're ready to exit.
   ShutdownRequestReceived = true;
   Reply(nullptr);

clang-tools-extra/clangd/SemanticHighlighting.h

 #include "ClangdUnit.h"
 #include "Protocol.h"
 
 namespace clang {
 namespace clangd {
 
 enum class HighlightingKind {
   Variable = 0,
-  Function = 1,
+  Function,
+
+  NumKinds,
 };
 
 // Contains all information needed for the highlighting a token.
 struct HighlightingToken {
   HighlightingKind Kind;
   Range R;
 };
 
 bool operator==(const HighlightingToken &Lhs, const HighlightingToken &Rhs);
 
 // Returns all HighlightingTokens from an AST. Only generates highlights for the
 // main AST.
 std::vector<HighlightingToken> getSemanticHighlightings(ParsedAST &AST);
 
-// Gets the TextMate scopes as a double nested array where the
-// SemanticHighlightKind indexes correctly into this vector.
-std::vector<std::vector<std::string>> getTextMateScopeLookupTable();
+/// Converts a HighlightingKind to a corresponding TextMate scope
+/// (https://manual.macromates.com/en/language_grammars).
+llvm::StringRef toTextMateScope(HighlightingKind Kind);
 
 // Convert to LSP's semantic highlighting information.
 std::vector<SemanticHighlightingInformation>
 toSemanticHighlightingInformation(llvm::ArrayRef<HighlightingToken> Tokens);
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/SemanticHighlighting.cpp

for (const auto &Line : TokenLines) {
     }
 
     Lines.push_back({Line.first, encodeBase64(LineByteTokens)});
   }
 
   return Lines;
 }
 
-std::vector<std::vector<std::string>> getTextMateScopeLookupTable() {
+llvm::StringRef toTextMateScope(HighlightingKind Kind) {
   // FIXME: Add scopes for C and Objective C.
-  std::map<HighlightingKind, std::vector<std::string>> Scopes = {
-      {HighlightingKind::Variable, {"variable.cpp"}},
-      {HighlightingKind::Function, {"entity.name.function.cpp"}}};
-  std::vector<std::vector<std::string>> NestedScopes(Scopes.size());
-  for (const auto &Scope : Scopes)
-    NestedScopes[static_cast<int>(Scope.first)] = Scope.second;
-
-  return NestedScopes;
+  switch (Kind) {
+  case HighlightingKind::Function:
+    return "entity.name.function.cpp";
+  case HighlightingKind::Variable:
+    return "variable.cpp";
+  case HighlightingKind::NumKinds:
+    llvm_unreachable("must not pass NumKinds to the function");
+  }
+  llvm_unreachable("unhandled HighlightingKind");
 }
 
 } // namespace clangd
 } // namespace clang

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"
 
 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 {