[clangd] Update the CompletionItemKind.

[hokein]

Summary

Fix some FIXMEs.

[kadircet]

clang-tools-extra/clangd/CodeComplete.cpp

107

I believe function still captures the intend better here, as you can only see the completion if you are literally completing for Foo.operator X() (btw, I am not even sure if we show completions for those, we might have another bug around this one).

So I would keep it the same, but up to you.

[hokein]

address comment

clang-tools-extra/clangd/CodeComplete.cpp

107

hmm, I'm not sure we will actually encounter this case in practice, the completion didn't show up on Foo.^ or Foo.operat^or, Foo.opeator ^ shows completion results, but seems not running into this code path.

Reverted back, and removed the fixme.

clang-tools-extra/clangd/CodeComplete.cpp

CompletionItemKind toCompletionItemKind(index::SymbolKind Kind) {
   case SK::Module:
   case SK::Namespace:
   case SK::NamespaceAlias:
     return CompletionItemKind::Module;
   case SK::Macro:
     return CompletionItemKind::Text;
   case SK::Enum:
     return CompletionItemKind::Enum;
-  // FIXME(ioeric): use LSP struct instead of class when it is suppoted in the
-  // protocol.
   case SK::Struct:
+    return CompletionItemKind::Struct;
   case SK::Class:
   case SK::Protocol:
   case SK::Extension:
   case SK::Union:
     return CompletionItemKind::Class;
   case SK::TypeAlias:
     // We use the same kind as the VSCode C++ extension.
     // FIXME: pick a better option when we have one.
     return CompletionItemKind::Interface;
   case SK::Using:
     return CompletionItemKind::Reference;
   case SK::Function:
-  // FIXME(ioeric): this should probably be an operator. This should be fixed
-  // when `Operator` is support type in the protocol.
   case SK::ConversionFunction:
     return CompletionItemKind::Function;
   case SK::Variable:
   case SK::Parameter:
   case SK::NonTypeTemplateParm:
     return CompletionItemKind::Variable;
   case SK::Field:
     return CompletionItemKind::Field;
-  // FIXME(ioeric): use LSP enum constant when it is supported in the protocol.
   case SK::EnumConstant:
-    return CompletionItemKind::Value;
+    return CompletionItemKind::EnumMember;
   case SK::InstanceMethod:
   case SK::ClassMethod:
   case SK::StaticMethod:
   case SK::Destructor:
     return CompletionItemKind::Method;
   case SK::InstanceProperty:
   case SK::ClassProperty:
   case SK::StaticProperty:

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

auto Results = completions(
           #define MACRO 10
           int X = ^
       )cpp",
       {func("indexFunction"), var("indexVariable"), cls("indexClass")});
   EXPECT_THAT(Results.Completions,
               AllOf(Has("function", CompletionItemKind::Function),
                     Has("variable", CompletionItemKind::Variable),
                     Has("int", CompletionItemKind::Keyword),
-                    Has("Struct", CompletionItemKind::Class),
+                    Has("Struct", CompletionItemKind::Struct),
                     Has("MACRO", CompletionItemKind::Text),
                     Has("indexFunction", CompletionItemKind::Function),
                     Has("indexVariable", CompletionItemKind::Variable),
                     Has("indexClass", CompletionItemKind::Class)));
 
   Results = completions("nam^");
   EXPECT_THAT(Results.Completions,
               Has("namespace", CompletionItemKind::Snippet));
EXPECT_THAT(
       UnorderedElementsAre(
           AllOf(Named("complete_class"), Kind(CompletionItemKind::Class)),
           AllOf(Named("complete_function"), Kind(CompletionItemKind::Function)),
           AllOf(Named("complete_type_alias"),
                 Kind(CompletionItemKind::Interface)),
           AllOf(Named("complete_variable"), Kind(CompletionItemKind::Variable)),
           AllOf(Named("complete_static_member"),
                 Kind(CompletionItemKind::Property))));
+
+   Results = completions(
+      R"cpp(
+        enum Color {
+          Red
+        };
+        Color u = ^
+      )cpp");
+   EXPECT_THAT(Results.Completions,
+               Contains(
+                   AllOf(Named("Red"), Kind(CompletionItemKind::EnumMember))));
 }
 
 TEST(CompletionTest, NoDuplicates) {
   auto Results = completions(
       R"cpp(
           class Adapter {
           };