[clangd] Added semantic highlighting for constructors and destructors.

[jvikstrom]

Summary

Add semantic highlighting to constructor and destructor declarations.

[jvikstrom]

Abandoning after discussion with sammccall and hokein.

clang-tools-extra/clangd/SemanticHighlighting.h

 #include "Protocol.h"
 
 namespace clang {
 namespace clangd {
 
 enum class HighlightingKind {
   Variable = 0,
   Function,
+  Constructor,
+  Destructor,
 
   NumKinds,
 };
 
 // Contains all information needed for the highlighting a token.
 struct HighlightingToken {
   HighlightingKind Kind;
   Range R;

clang-tools-extra/clangd/SemanticHighlighting.cpp

public:
   std::vector<HighlightingToken> collectTokens() {
     Tokens.clear();
     TraverseAST(Ctx);
     return Tokens;
   }
 
   bool VisitNamedDecl(NamedDecl *ND) {
     // FIXME: (De)Constructors/operator need to be highlighted some other way.
-    if (ND->getDeclName().getNameKind() != DeclarationName::Identifier)
+    auto Kind = ND->getDeclName().getNameKind();
+    if (Kind != DeclarationName::Identifier &&
+        Kind != DeclarationName::CXXConstructorName &&
+        Kind != DeclarationName::CXXDestructorName)
       return true;
 
     if (ND->getDeclName().isEmpty())
       // Don't add symbols that don't have any length.
       return true;
     addToken(ND->getLocation(), ND);
     return true;
   }
 
   bool VisitDeclRefExpr(DeclRefExpr *Ref) {
     if (Ref->getNameInfo().getName().getNameKind() !=
         DeclarationName::Identifier)
       // Only want to highlight identifiers.
       return true;
 
     addToken(Ref->getLocation(), Ref->getDecl());
     return true;
   }
 
 private:
   void addToken(SourceLocation Loc, const Decl *D) {
+    if (Loc.isMacroID())
+      // FIXME: skip tokens inside macros for now.
+      return;
+
+    if(isa<CXXConstructorDecl>(D)) {
+      addToken(Loc, HighlightingKind::Constructor);
+      return;
+    }
+    if (isa<CXXDestructorDecl>(D)) {
+      addToken(
+          Loc,
+          dyn_cast<CXXDestructorDecl>(D)->getDeclName().getAsString().size(),
+          HighlightingKind::Destructor);
+      return;
+    }
     if (isa<VarDecl>(D)) {
       addToken(Loc, HighlightingKind::Variable);
       return;
     }
     if (isa<FunctionDecl>(D)) {
       addToken(Loc, HighlightingKind::Function);
       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);
     if (!R) {
       // R should always have a value, if it doesn't something is very wrong.
       elog("Tried to add semantic token with an invalid range");
       return;
     }
 
     Tokens.push_back({Kind, R.getValue()});
   }
+  void addToken(SourceLocation Loc, int Len, HighlightingKind Kind) {
+    auto StartLoc = sourceLocToPosition(SM, Loc);
+    Position EndLoc;
+    EndLoc.line = StartLoc.line;
+    EndLoc.character = StartLoc.character + Len;
+    Tokens.push_back({Kind, {StartLoc, EndLoc}});
+  }
 };
 
 // Encode binary data into base64.
 // This was copied from compiler-rt/lib/fuzzer/FuzzerUtil.cpp.
 // FIXME: Factor this out into llvm/Support?
 std::string encodeBase64(const llvm::SmallVectorImpl<char> &Bytes) {
   static const char Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                               "abcdefghijklmnopqrstuvwxyz"

 
 llvm::StringRef toTextMateScope(HighlightingKind Kind) {
   // FIXME: Add scopes for C and Objective C.
   switch (Kind) {
   case HighlightingKind::Function:
     return "entity.name.function.cpp";
   case HighlightingKind::Variable:
     return "variable.cpp";
+  case HighlightingKind::Constructor:
+    return "entity.name.function.constructor.cpp";
+  case HighlightingKind::Destructor:
+    return "entity.name.function.destructor.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/test/semantic-highlighting.test

 # RUN: clangd -lit-test < %s | FileCheck -strict-whitespace %s
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{"textDocument":{"semanticHighlightingCapabilities":{"semanticHighlighting":true}}},"trace":"off"}}
 ---
 #      CHECK:  "id": 0,
 # CHECK:      "semanticHighlighting": {
 # CHECK-NEXT:        "scopes": [
 # CHECK-NEXT:          [
 # CHECK-NEXT:            "variable.cpp"
 # CHECK-NEXT:          ],
 # CHECK-NEXT:          [
 # CHECK-NEXT:            "entity.name.function.cpp"
 # CHECK-NEXT:          ]
+# CHECK-NEXT:          [
+# CHECK-NEXT:            "entity.name.function.constructor.cpp"
+# CHECK-NEXT:          ],
+# CHECK-NEXT:          [
+# CHECK-NEXT:            "entity.name.function.destructor.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": [
 # CHECK-NEXT:      {

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

makeHighlightingTokens(llvm::ArrayRef<Range> Ranges, HighlightingKind Kind) {
   return Tokens;
 }
 
 void checkHighlightings(llvm::StringRef Code) {
   Annotations Test(Code);
   auto AST = TestTU::withCode(Test.code()).build();
   static const std::map<HighlightingKind, std::string> KindToString{
       {HighlightingKind::Variable, "Variable"},
-      {HighlightingKind::Function, "Function"}};
+      {HighlightingKind::Function, "Function"},
+      {HighlightingKind::Constructor, "Constructor"},
+      {HighlightingKind::Destructor, "Destructor"}};
   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(
       void $Function[[foo]](int);
       void $Function[[Gah]]();
       void $Function[[foo]]() {
         auto $Variable[[Bou]] = $Function[[Gah]];
       }
     )cpp",
     R"cpp(
       struct A {
-        A();
-        ~A();
+        $Constructor[[A]]();
+        $Destructor[[~A]]()  {}
         void $Function[[abc]]();
         void operator<<(int);
       };
+      struct B {};
     )cpp"};
   for (const auto &TestCase : TestCases) {
     checkHighlightings(TestCase);
   }
 }
 
 TEST(SemanticHighlighting, GeneratesHighlightsWhenFileChange) {
   class HighlightingsCounterDiagConsumer : public DiagnosticsConsumer {