[clangd] Boost keyword completions.

[sammccall]

Summary

These have few signals other than being keywords, so the boost is high.

[ilya-biryukov]

LGTM.

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

 /// Attributes of a symbol that affect how much we like it.
 struct SymbolQualitySignals {
   bool Deprecated = false;
   bool ReservedName = false; // __foo, _Foo are usually implementation details.
                              // FIXME: make these findable once user types _.
   unsigned References = 0;
 
   enum SymbolCategory {
+    Unknown = 0,
     Variable,
     Macro,
     Type,
     Function,
     Namespace,
-    Unknown,
+    Keyword,
   } Category = Unknown;
 
   void merge(const CodeCompletionResult &SemaCCResult);
   void merge(const Symbol &IndexResult);
 
   // Condense these signals down to a single number, higher is better.
   float evaluate() const;
 };

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

SymbolQualitySignals::SymbolCategory Visit##DeclType(const DeclType *) {     \
     MAP(FunctionDecl, Function);
     MAP(FunctionTemplateDecl, Function);
     MAP(Decl, Unknown);
 #undef MAP
   };
   return Switch().Visit(&ND);
 }
 
+static SymbolQualitySignals::SymbolCategory categorize(const CodeCompletionResult &R) {
+  if (R.Declaration)
+    return categorize(*R.Declaration);
+  if (R.Kind == CodeCompletionResult::RK_Macro)
+    return SymbolQualitySignals::Macro;
+  // Everything else is a keyword or a pattern. Patterns are mostly keywords
+  // too, except a few which we recognize by cursor kind.
+  switch (R.CursorKind) {
+    case CXCursor_CXXMethod:
+      return SymbolQualitySignals::Function;
+    case CXCursor_ModuleImportDecl:
+      return SymbolQualitySignals::Namespace;
+    case CXCursor_MacroDefinition:
+      return SymbolQualitySignals::Macro;
+    case CXCursor_TypeRef:
+      return SymbolQualitySignals::Type;
+    case CXCursor_MemberRef:
+      return SymbolQualitySignals::Variable;
+    default:
+      return SymbolQualitySignals::Keyword;
+  }
+}
+
 static SymbolQualitySignals::SymbolCategory
 categorize(const index::SymbolInfo &D) {
   switch (D.Kind) {
     case index::SymbolKind::Namespace:
     case index::SymbolKind::NamespaceAlias:
       return SymbolQualitySignals::Namespace;
     case index::SymbolKind::Macro:
       return SymbolQualitySignals::Macro;
categorize(const index::SymbolInfo &D) {
   }
   llvm_unreachable("Unknown index::SymbolKind");
 }
 
 void SymbolQualitySignals::merge(const CodeCompletionResult &SemaCCResult) {
   if (SemaCCResult.Availability == CXAvailability_Deprecated)
     Deprecated = true;
 
-  if (SemaCCResult.Declaration)
-    Category = categorize(*SemaCCResult.Declaration);
-  else if (SemaCCResult.Kind == CodeCompletionResult::RK_Macro)
-    Category = Macro;
+  Category = categorize(SemaCCResult);
 
   if (SemaCCResult.Declaration) {
     if (auto *ID = SemaCCResult.Declaration->getIdentifier())
       ReservedName = ReservedName || IsReserved(ID->getName());
   } else if (SemaCCResult.Kind == CodeCompletionResult::RK_Macro)
     ReservedName = ReservedName || IsReserved(SemaCCResult.Macro->getName());
 }
 
if (References >= 3)
     Score *= std::log(References);
 
   if (Deprecated)
     Score *= 0.1f;
   if (ReservedName)
     Score *= 0.1f;
 
   switch (Category) {
+    case Keyword:  // Usually relevant, but misses most signals.
+      Score *= 10;
+      break;
     case Type:
     case Function:
     case Variable:
       Score *= 1.1f;
       break;
     case Namespace:
       Score *= 0.8f;
       break;

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

TEST(QualityTests, SymbolQualitySignalExtraction) {
   EXPECT_EQ(Quality.Category, SymbolQualitySignals::Function);
 
   Quality = {};
   Quality.merge(CodeCompletionResult(&findDecl(AST, "_f"), /*Priority=*/42));
   EXPECT_TRUE(Quality.Deprecated);
   EXPECT_FALSE(Quality.ReservedName);
   EXPECT_EQ(Quality.References, SymbolQualitySignals().References);
   EXPECT_EQ(Quality.Category, SymbolQualitySignals::Function);
+
+  Quality = {};
+  Quality.merge(CodeCompletionResult("if"));
+  EXPECT_EQ(Quality.Category, SymbolQualitySignals::Keyword);
 }
 
 TEST(QualityTests, SymbolRelevanceSignalExtraction) {
   TestTU Test;
   Test.HeaderCode = R"cpp(
     int header();
     int header_main();
     )cpp";
TEST(QualityTests, SymbolQualitySignalsSanity) {
   EXPECT_LT(ReservedName.evaluate(), Default.evaluate());
 
   SymbolQualitySignals WithReferences, ManyReferences;
   WithReferences.References = 10;
   ManyReferences.References = 1000;
   EXPECT_GT(WithReferences.evaluate(), Default.evaluate());
   EXPECT_GT(ManyReferences.evaluate(), WithReferences.evaluate());
 
-  SymbolQualitySignals Variable, Macro;
+  SymbolQualitySignals Keyword, Variable, Macro;
+  Keyword.Category = SymbolQualitySignals::Keyword;
   Variable.Category = SymbolQualitySignals::Variable;
   Macro.Category = SymbolQualitySignals::Macro;
   EXPECT_GT(Variable.evaluate(), Default.evaluate());
+  EXPECT_GT(Keyword.evaluate(), Variable.evaluate());
   EXPECT_LT(Macro.evaluate(), Default.evaluate());
 }
 
 TEST(QualityTests, SymbolRelevanceSignalsSanity) {
   SymbolRelevanceSignals Default;
   EXPECT_EQ(Default.evaluate(), 1);
 
   SymbolRelevanceSignals Forbidden;