[clangd] Added highlightings for template parameters and specializations.

[jvikstrom]

Summary

Template parameters and specializations were not being highlighted before. This adds highlightings to those types of tokens by adding two Visit* methods.

[hokein]

clang-tools-extra/clangd/SemanticHighlighting.cpp

141 ↗

(On Diff #210272)

nit: clang-format

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

179 ↗

(On Diff #210272)

could you add some more test cases?

• for unnamed template parameter, template <typename> class Foo {};
• for partial template specialization

[jvikstrom]

Added testcases and made highlighting work for template template parameters as well.

[hokein]

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

179 ↗

(On Diff #210272)

Looks like you are still missing the unnamed template parameter template <typename> class Foo {}; case

[jvikstrom]

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

179 ↗

(On Diff #210272)

Oh sorry, added it and landed.

clang-tools-extra/trunk/clangd/SemanticHighlighting.h

enum class HighlightingKind {
   Variable = 0,
   Function,
   Method,
   Field,
   Class,
   Enum,
   EnumConstant,
   Namespace,
+  TemplateParameter,
 
   NumKinds,
 };
 
 // Contains all information needed for the highlighting a token.
 struct HighlightingToken {
   HighlightingKind Kind;
   Range R;

clang-tools-extra/trunk/clangd/SemanticHighlighting.cpp

public:
   }
 
   bool VisitTypedefNameDecl(TypedefNameDecl *TD) {
     if(const auto *TSI = TD->getTypeSourceInfo())
       addTypeLoc(TD->getLocation(), TSI->getTypeLoc());
     return true;
   }
 
+  bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc &TL) {
+    // TemplateTypeParmTypeLoc does not have a TagDecl in its type ptr.
+    addToken(TL.getBeginLoc(), TL.getDecl());
+    return true;
+  }
+
+  bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc &TL) {
+    if (const TemplateDecl *TD =
+            TL.getTypePtr()->getTemplateName().getAsTemplateDecl())
+      addToken(TL.getBeginLoc(), TD);
+    return true;
+  }
+
   bool VisitTypeLoc(TypeLoc &TL) {
     // This check is for not getting two entries when there are anonymous
     // structs. It also makes us not highlight certain namespace qualifiers
     // twice. For elaborated types the actual type is highlighted as an inner
     // TypeLoc.
     if (TL.getTypeLocClass() == TypeLoc::TypeLocClass::Elaborated)
       return true;
 
private:
 
   void addToken(SourceLocation Loc, const NamedDecl *D) {
     if (D->getDeclName().isIdentifier() && D->getName().empty())
       // Don't add symbols that don't have any length.
       return;
     // We highlight class decls, constructor decls and destructor decls as
     // `Class` type. The destructor decls are handled in `VisitTypeLoc` (we will
     // visit a TypeLoc where the underlying Type is a CXXRecordDecl).
+    if (isa<ClassTemplateDecl>(D)) {
+      addToken(Loc, HighlightingKind::Class);
+      return;
+    }
     if (isa<RecordDecl>(D)) {
       addToken(Loc, HighlightingKind::Class);
       return;
     }
     if (isa<CXXConstructorDecl>(D)) {
       addToken(Loc, HighlightingKind::Class);
       return;
     }
void addToken(SourceLocation Loc, const NamedDecl *D) {
     if (isa<NamespaceDecl>(D)) {
       addToken(Loc, HighlightingKind::Namespace);
       return;
     }
     if (isa<NamespaceAliasDecl>(D)) {
       addToken(Loc, HighlightingKind::Namespace);
       return;
     }
+    if (isa<TemplateTemplateParmDecl>(D)) {
+      addToken(Loc, HighlightingKind::TemplateParameter);
+      return;
+    }
+    if (isa<TemplateTypeParmDecl>(D)) {
+      addToken(Loc, HighlightingKind::TemplateParameter);
+      return;
+    }
   }
 
   void addToken(SourceLocation Loc, HighlightingKind Kind) {
     if (Loc.isMacroID())
       // FIXME: skip tokens inside macros for now.
       return;
 
     auto R = getTokenRange(SM, Ctx.getLangOpts(), Loc);
llvm::StringRef toTextMateScope(HighlightingKind Kind) {
   case HighlightingKind::Class:
     return "entity.name.type.class.cpp";
   case HighlightingKind::Enum:
     return "entity.name.type.enum.cpp";
   case HighlightingKind::EnumConstant:
     return "variable.other.enummember.cpp";
   case HighlightingKind::Namespace:
     return "entity.name.namespace.cpp";
+  case HighlightingKind::TemplateParameter:
+    return "entity.name.type.template.cpp";
   case HighlightingKind::NumKinds:
     llvm_unreachable("must not pass NumKinds to the function");
   }
   llvm_unreachable("unhandled HighlightingKind");
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/trunk/clangd/test/semantic-highlighting.test

 # CHECK-NEXT:          [
 # CHECK-NEXT:            "entity.name.type.enum.cpp"
 # CHECK-NEXT:          ],
 # CHECK-NEXT:          [
 # CHECK-NEXT:            "variable.other.enummember.cpp"
 # CHECK-NEXT:          ],
 # CHECK-NEXT:          [
 # CHECK-NEXT:            "entity.name.namespace.cpp"
+# CHECK-NEXT:          ],
+# CHECK-NEXT:          [
+# CHECK-NEXT:            "entity.name.type.template.cpp"
 # CHECK-NEXT:          ]
 # CHECK-NEXT:        ]
 # CHECK-NEXT:      },
 ---
 {"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"test:///foo.cpp","languageId":"cpp","version":1,"text":"int x = 2;"}}}
 #      CHECK:  "method": "textDocument/semanticHighlighting",
 # CHECK-NEXT:  "params": {
 # CHECK-NEXT:    "lines": [

clang-tools-extra/trunk/clangd/unittests/SemanticHighlightingTests.cpp

void checkHighlightings(llvm::StringRef Code) {
   static const std::map<HighlightingKind, std::string> KindToString{
       {HighlightingKind::Variable, "Variable"},
       {HighlightingKind::Function, "Function"},
       {HighlightingKind::Class, "Class"},
       {HighlightingKind::Enum, "Enum"},
       {HighlightingKind::Namespace, "Namespace"},
       {HighlightingKind::EnumConstant, "EnumConstant"},
       {HighlightingKind::Field, "Field"},
-      {HighlightingKind::Method, "Method"}};
+      {HighlightingKind::Method, "Method"},
+      {HighlightingKind::TemplateParameter, "TemplateParameter"}};
   std::vector<HighlightingToken> ExpectedTokens;
   for (const auto &KindString : KindToString) {
     std::vector<HighlightingToken> Toks = makeHighlightingTokens(
         Test.ranges(KindString.second), KindString.first);
     ExpectedTokens.insert(ExpectedTokens.end(), Toks.begin(), Toks.end());
   }
 
   auto ActualTokens = getSemanticHighlightings(AST);
R"cpp(
         auto $Variable[[Bou]] = $Function[[Gah]];
       }
       struct $Class[[A]] {
         void $Method[[abc]]();
       };
     )cpp",
     R"cpp(
       namespace $Namespace[[abc]] {
-        template<typename T>
+        template<typename $TemplateParameter[[T]]>
         struct $Class[[A]] {
-          T $Field[[t]];
+          $TemplateParameter[[T]] $Field[[t]];
         };
       }
-      template<typename T>
-      struct $Class[[C]] : $Namespace[[abc]]::A<T> {
-        typename T::A* $Field[[D]];
+      template<typename $TemplateParameter[[T]]>
+      struct $Class[[C]] : $Namespace[[abc]]::$Class[[A]]<$TemplateParameter[[T]]> {
+        typename $TemplateParameter[[T]]::A* $Field[[D]];
       };
       $Namespace[[abc]]::$Class[[A]]<int> $Variable[[AA]];
       typedef $Namespace[[abc]]::$Class[[A]]<int> $Class[[AAA]];
       struct $Class[[B]] {
         $Class[[B]]();
         ~$Class[[B]]();
         void operator<<($Class[[B]]);
         $Class[[AAA]] $Field[[AA]];
R"cpp(
       typedef $Namespace[[a]]::$Class[[A]] $Class[[B]];
       using $Class[[BB]] = $Namespace[[a]]::$Class[[A]];
       enum class $Enum[[E]] {};
       typedef $Enum[[E]] $Enum[[C]];
       typedef $Enum[[C]] $Enum[[CC]];
       using $Enum[[CD]] = $Enum[[CC]];
       $Enum[[CC]] $Function[[f]]($Class[[B]]);
       $Enum[[CD]] $Function[[f]]($Class[[BB]]);
+    )cpp",
+    R"cpp(
+      template<typename $TemplateParameter[[T]], typename = void>
+      class $Class[[A]] {
+        $TemplateParameter[[T]] $Field[[AA]];
+        $TemplateParameter[[T]] $Method[[foo]]();
+      };
+      template<class $TemplateParameter[[TT]]>
+      class $Class[[B]] {
+        $Class[[A]]<$TemplateParameter[[TT]]> $Field[[AA]];
+      };
+      template<class $TemplateParameter[[TT]], class $TemplateParameter[[GG]]>
+      class $Class[[BB]] {};
+      template<class $TemplateParameter[[T]]>
+      class $Class[[BB]]<$TemplateParameter[[T]], int> {};
+      template<class $TemplateParameter[[T]]>
+      class $Class[[BB]]<$TemplateParameter[[T]], $TemplateParameter[[T]]*> {};
+
+      template<template<class> class $TemplateParameter[[T]], class $TemplateParameter[[C]]>
+      $TemplateParameter[[T]]<$TemplateParameter[[C]]> $Function[[f]]();
+
+      template<typename>
+      class $Class[[Foo]] {};
+
+      template<typename $TemplateParameter[[T]]>
+      void $Function[[foo]]($TemplateParameter[[T]] ...);
     )cpp"};
   for (const auto &TestCase : TestCases) {
     checkHighlightings(TestCase);
   }
 }
 
 TEST(SemanticHighlighting, GeneratesHighlightsWhenFileChange) {
   class HighlightingsCounterDiagConsumer : public DiagnosticsConsumer {