[clangd] Mark "override" and "final" as modifiers

[ckandeler]

Summary

... in semantic highlighting.
These specifiers cannot be identified by simple lexing (since e.g.
variables with these names can legally be declared), which means they
should be semantic tokens.

[sammccall]

LGTM with optional mechanical replacement of Keyword with Modifier.

clang-tools-extra/clangd/SemanticHighlighting.h

52

LSP provides both keyword and modifier, which obviously overlap.
I think modifier is more specific and applies here, so would lean towards that. WDYT?

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

868

can you add something like int override, final; to check that these are *not* highlighted?

872

this comment should not be inside the string literal

[ckandeler]

Incorporated review comments.

clang-tools-extra/clangd/SemanticHighlighting.h

enum class HighlightingKind {
   Typedef,
   Type,
   Unknown,
   Namespace,
   TemplateParameter,
   Concept,
   Primitive,
   Macro,
+  Keyword,
 
   // This one is different from the other kinds as it's a line style
   // rather than a token style.
   InactiveCode,
 
   LastKind = InactiveCode
 };
 

clang-tools-extra/clangd/SemanticHighlighting.cpp

public:
 
   bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
     H.addToken(E->getNameInfo().getLoc(), HighlightingKind::Unknown)
         .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
     return true;
   }
 
+  bool VisitAttr(Attr *A) {
+    switch (A->getKind()) {
+    case attr::Override:
+    case attr::Final:
+      H.addToken(A->getLocation(), HighlightingKind::Keyword);
+      break;
+    default:
+      break;
+    }
+    return true;
+  }
+
   bool VisitDependentNameTypeLoc(DependentNameTypeLoc L) {
     H.addToken(L.getNameLoc(), HighlightingKind::Type)
         .addModifier(HighlightingModifier::DependentName)
         .addModifier(HighlightingModifier::ClassScope);
     return true;
   }
 
   bool VisitDependentTemplateSpecializationTypeLoc(
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K) {
   case HighlightingKind::TemplateParameter:
     return OS << "TemplateParameter";
   case HighlightingKind::Concept:
     return OS << "Concept";
   case HighlightingKind::Primitive:
     return OS << "Primitive";
   case HighlightingKind::Macro:
     return OS << "Macro";
+  case HighlightingKind::Keyword:
+    return OS << "Keyword";
   case HighlightingKind::InactiveCode:
     return OS << "InactiveCode";
   }
   llvm_unreachable("invalid HighlightingKind");
 }
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingModifier K) {
   switch (K) {
   case HighlightingModifier::Declaration:
llvm::StringRef toSemanticTokenType(HighlightingKind Kind) {
   case HighlightingKind::TemplateParameter:
     return "typeParameter";
   case HighlightingKind::Concept:
     return "concept"; // nonstandard
   case HighlightingKind::Primitive:
     return "type";
   case HighlightingKind::Macro:
     return "macro";
+  case HighlightingKind::Keyword:
+    return "keyword";
   case HighlightingKind::InactiveCode:
     return "comment";
   }
   llvm_unreachable("unhandled HighlightingKind");
 }
 
 llvm::StringRef toSemanticTokenModifier(HighlightingModifier Modifier) {
   switch (Modifier) {

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

)cpp",
         }
       )cpp",
       // Predefined identifiers
       R"cpp(
         void $Function_def[[Foo]]() {
             const char *$LocalVariable_def_readonly[[s]] = $LocalVariable_readonly_static[[__func__]];
         }
       )cpp",
+      // override and final
+      R"cpp(
+        class $Class_def_abstract[[Base]] { virtual void $Method_decl_abstract_virtual[[m]]() = 0; };
+        class $Class_def[[Derived]] : public $Class_abstract[[Base]] { void $Method_decl_virtual[[m]]() $Keyword[[override]]; };
+        class $Class_def[[MoreDerived]] : public $Class[[Derived]] { void $Method_decl_virtual[[m]]() $Keyword[[final]]; };
       // Issue 1222: readonly modifier for generic parameter
+      )cpp",
       R"cpp(
         template <typename $TemplateParameter_def[[T]]>
         auto $Function_def[[foo]](const $TemplateParameter[[T]] $Parameter_def_readonly[[template_type]], 
                                   const $TemplateParameter[[auto]] $Parameter_def_readonly[[auto_type]], 
                                   const int $Parameter_def_readonly[[explicit_type]]) {
             return $Parameter_readonly[[template_type]] 
                  + $Parameter_readonly[[auto_type]] 
                  + $Parameter_readonly[[explicit_type]];