[clangd] Use enumMember instead of enumConstant

[njames93]

Summary

We should be using enumMember as thats defined in LSP, enumConstant is non standard so clients aren't likely to support it
Fixes https://github.com/clangd/clangd/issues/622

[sammccall]

Thanks! Most of the changes in this patch are to the internal infrastructure, which predates LSP semanticTokens and doesn't need to have names that match (in many cases the names don't closely match C++ convention).
I think only the toSemanticTokenType change is needed.

clang-tools-extra/clangd/SemanticHighlighting.h

51

HighlightingKind is an internal enum that doesn't match LSP naming, so no need for changes there.

[njames93]

clang-tools-extra/clangd/SemanticHighlighting.h

51

It doesn't strictly need it, But I do like the consistency of it being EnumMember throughout. I'll revert though as its not essential.

[njames93]

Remove changes to internal infrastructure.

clang-tools-extra/clangd/SemanticHighlighting.h

enum class HighlightingKind {
   Parameter,
   Function,
   Method,
   StaticMethod,
   Field,
   StaticField,
   Class,
   Enum,
-  EnumConstant,
+  EnumMember,
   Typedef,
   DependentType,
   DependentName,
   Namespace,
   TemplateParameter,
   Concept,
   Primitive,
   Macro,

clang-tools-extra/clangd/SemanticHighlighting.cpp

llvm::Optional<HighlightingKind> kindForDecl(const NamedDecl *D) {
   if (auto *MD = dyn_cast<CXXMethodDecl>(D))
     return MD->isStatic() ? HighlightingKind::StaticMethod
                           : HighlightingKind::Method;
   if (isa<FieldDecl>(D))
     return HighlightingKind::Field;
   if (isa<EnumDecl>(D))
     return HighlightingKind::Enum;
   if (isa<EnumConstantDecl>(D))
-    return HighlightingKind::EnumConstant;
+    return HighlightingKind::EnumMember;
   if (isa<ParmVarDecl>(D))
     return HighlightingKind::Parameter;
   if (auto *VD = dyn_cast<VarDecl>(D))
     return VD->isStaticDataMember()
                ? HighlightingKind::StaticField
                : VD->isLocalVarDecl() ? HighlightingKind::LocalVariable
                                       : HighlightingKind::Variable;
   if (const auto *BD = dyn_cast<BindingDecl>(D))
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K) {
   case HighlightingKind::Field:
     return OS << "Field";
   case HighlightingKind::StaticField:
     return OS << "StaticField";
   case HighlightingKind::Class:
     return OS << "Class";
   case HighlightingKind::Enum:
     return OS << "Enum";
-  case HighlightingKind::EnumConstant:
-    return OS << "EnumConstant";
+  case HighlightingKind::EnumMember:
+    return OS << "EnumMember";
   case HighlightingKind::Typedef:
     return OS << "Typedef";
   case HighlightingKind::DependentType:
     return OS << "DependentType";
   case HighlightingKind::DependentName:
     return OS << "DependentName";
   case HighlightingKind::Namespace:
     return OS << "Namespace";
case HighlightingKind::StaticMethod:
     // FIXME: better method with static modifier?
     return "function";
   case HighlightingKind::Field:
     return "property";
   case HighlightingKind::Class:
     return "class";
   case HighlightingKind::Enum:
     return "enum";
-  case HighlightingKind::EnumConstant:
-    return "enumConstant"; // nonstandard
+  case HighlightingKind::EnumMember:
+    return "enumMember";
   case HighlightingKind::Typedef:
     return "type";
   case HighlightingKind::DependentType:
     return "dependent"; // nonstandard
   case HighlightingKind::DependentName:
     return "dependent"; // nonstandard
   case HighlightingKind::Namespace:
     return "namespace";
llvm::StringRef toTextMateScope(HighlightingKind Kind) {
   case HighlightingKind::Field:
     return "variable.other.field.cpp";
   case HighlightingKind::StaticField:
     return "variable.other.field.static.cpp";
   case HighlightingKind::Class:
     return "entity.name.type.class.cpp";
   case HighlightingKind::Enum:
     return "entity.name.type.enum.cpp";
-  case HighlightingKind::EnumConstant:
+  case HighlightingKind::EnumMember:
     return "variable.other.enummember.cpp";
   case HighlightingKind::Typedef:
     return "entity.name.type.typedef.cpp";
   case HighlightingKind::DependentType:
     return "entity.name.type.dependent.cpp";
   case HighlightingKind::DependentName:
     return "entity.name.other.dependent.cpp";
   case HighlightingKind::Namespace:

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

std::vector<HighlightingToken> getExpectedTokens(Annotations &Test) {
   static const std::map<HighlightingKind, std::string> KindToString{
       {HighlightingKind::Variable, "Variable"},
       {HighlightingKind::LocalVariable, "LocalVariable"},
       {HighlightingKind::Parameter, "Parameter"},
       {HighlightingKind::Function, "Function"},
       {HighlightingKind::Class, "Class"},
       {HighlightingKind::Enum, "Enum"},
       {HighlightingKind::Namespace, "Namespace"},
-      {HighlightingKind::EnumConstant, "EnumConstant"},
+      {HighlightingKind::EnumMember, "EnumMember"},
       {HighlightingKind::Field, "Field"},
       {HighlightingKind::StaticField, "StaticField"},
       {HighlightingKind::Method, "Method"},
       {HighlightingKind::StaticMethod, "StaticMethod"},
       {HighlightingKind::Typedef, "Typedef"},
       {HighlightingKind::DependentType, "DependentType"},
       {HighlightingKind::DependentName, "DependentName"},
       {HighlightingKind::TemplateParameter, "TemplateParameter"},
)cpp",
       void $Function[[f]] () {
         $Class[[B]] $LocalVariable[[BB]] = $Class[[B]]();
         $LocalVariable[[BB]].~$Class[[B]]();
         $Class[[B]]();
       }
     )cpp",
       R"cpp(
       enum class $Enum[[E]] {
-        $EnumConstant[[A]],
-        $EnumConstant[[B]],
+        $EnumMember[[A]],
+        $EnumMember[[B]],
       };
       enum $Enum[[EE]] {
-        $EnumConstant[[Hi]],
+        $EnumMember[[Hi]],
       };
       struct $Class[[A]] {
         $Enum[[E]] $Field[[EEE]];
         $Enum[[EE]] $Field[[EEEE]];
       };
-      int $Variable[[I]] = $EnumConstant[[Hi]];
-      $Enum[[E]] $Variable[[L]] = $Enum[[E]]::$EnumConstant[[B]];
+      int $Variable[[I]] = $EnumMember[[Hi]];
+      $Enum[[E]] $Variable[[L]] = $Enum[[E]]::$EnumMember[[B]];
     )cpp",
       R"cpp(
       namespace $Namespace[[abc]] {
         namespace {}
         namespace $Namespace[[bcd]] {
           struct $Class[[A]] {};
           namespace $Namespace[[cde]] {
             struct $Class[[A]] {
               enum class $Enum[[B]] {
-                $EnumConstant[[Hi]],
+                $EnumMember[[Hi]],
               };
             };
           }
         }
       }
       using namespace $Namespace[[abc]]::$Namespace[[bcd]];
       namespace $Namespace[[vwz]] =
             $Namespace[[abc]]::$Namespace[[bcd]]::$Namespace[[cde]];
       $Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable[[AA]];
       $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]] $Variable[[AAA]] =
-            $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]]::$EnumConstant[[Hi]];
+            $Namespace[[vwz]]::$Class[[A]]::$Enum[[B]]::$EnumMember[[Hi]];
       ::$Namespace[[vwz]]::$Class[[A]] $Variable[[B]];
       ::$Namespace[[abc]]::$Namespace[[bcd]]::$Class[[A]] $Variable[[BB]];
     )cpp",
       R"cpp(
       struct $Class[[D]] {
         double $Field[[C]];
       };
       struct $Class[[A]] {
)cpp",
         $Class[[B]] $Field[[BB]];
         $Class[[A]] &operator=($Class[[A]] &&$Parameter[[O]]);
       };
 
       $Class[[A]] &$Class[[A]]::operator=($Class[[A]] &&$Parameter[[O]]) = default;
     )cpp",
       R"cpp(
       enum $Enum[[En]] {
-        $EnumConstant[[EC]],
+        $EnumMember[[EC]],
       };
       class $Class[[Foo]] {};
       class $Class[[Bar]] {
       public:
         $Class[[Foo]] $Field[[Fo]];
         $Enum[[En]] $Field[[E]];
         int $Field[[I]];
         $Class[[Bar]] ($Class[[Foo]] $Parameter[[F]],
                 $Enum[[En]] $Parameter[[E]])
         : $Field[[Fo]] ($Parameter[[F]]), $Field[[E]] ($Parameter[[E]]),
           $Field[[I]] (123) {}
       };
       class $Class[[Bar2]] : public $Class[[Bar]] {
-        $Class[[Bar2]]() : $Class[[Bar]]($Class[[Foo]](), $EnumConstant[[EC]]) {}
+        $Class[[Bar2]]() : $Class[[Bar]]($Class[[Foo]](), $EnumMember[[EC]]) {}
       };
     )cpp",
       R"cpp(
       enum $Enum[[E]] {
-        $EnumConstant[[E]],
+        $EnumMember[[E]],
       };
       class $Class[[Foo]] {};
-      $Enum[[auto]] $Variable[[AE]] = $Enum[[E]]::$EnumConstant[[E]];
+      $Enum[[auto]] $Variable[[AE]] = $Enum[[E]]::$EnumMember[[E]];
       $Class[[auto]] $Variable[[AF]] = $Class[[Foo]]();
       $Class[[decltype]](auto) $Variable[[AF2]] = $Class[[Foo]]();
       $Class[[auto]] *$Variable[[AFP]] = &$Variable[[AF]];
       $Enum[[auto]] &$Variable[[AER]] = $Variable[[AE]];
       $Primitive[[auto]] $Variable[[Form]] = 10.2 + 2 * 4;
       $Primitive[[decltype]]($Variable[[Form]]) $Variable[[F]] = 10;
       auto $Variable[[Fun]] = []()->void{};
     )cpp",