[clangd] Rename evaluate() to evaluateHeuristics()

[usaxena95]

Summary

Since we have 2 scoring functions (heuristics and decision forest),
renaming the existing evaluate() function to be more descriptive of the
Heuristics being evaluated in it.

[adamcz]

Thanks!

clang-tools-extra/clangd/CodeComplete.cpp

private:
 
   CodeCompletion::Scores
   evaluateCompletion(const SymbolQualitySignals &Quality,
                      const SymbolRelevanceSignals &Relevance) {
     using RM = CodeCompleteOptions::CodeCompletionRankingModel;
     CodeCompletion::Scores Scores;
     switch (Opts.RankingModel) {
     case RM::Heuristics:
-      Scores.Quality = Quality.evaluate();
-      Scores.Relevance = Relevance.evaluate();
+      Scores.Quality = Quality.evaluateHeuristics();
+      Scores.Relevance = Relevance.evaluateHeuristics();
       Scores.Total =
           evaluateSymbolAndRelevance(Scores.Quality, Scores.Relevance);
       // NameMatch is in fact a multiplier on total score, so rescoring is
       // sound.
       Scores.ExcludingName = Relevance.NameMatch
                                  ? Scores.Total / Relevance.NameMatch
                                  : Scores.Quality;
       return Scores;

clang-tools-extra/clangd/FindSymbols.cpp

Index->fuzzyFind(Req, [HintPath, &Top, &Filter](const Symbol &Sym) {
     if (auto NameMatch = Filter.match(Sym.Name))
       Relevance.NameMatch = *NameMatch;
     else {
       log("Workspace symbol: {0} didn't match query {1}", Sym.Name,
           Filter.pattern());
       return;
     }
     Relevance.merge(Sym);
-    auto Score =
-        evaluateSymbolAndRelevance(Quality.evaluate(), Relevance.evaluate());
+    auto Score = evaluateSymbolAndRelevance(Quality.evaluateHeuristics(),
+                                            Relevance.evaluateHeuristics());
     dlog("FindSymbols: {0}{1} = {2}\n{3}{4}\n", Sym.Scope, Sym.Name, Score,
          Quality, Relevance);
 
     Top.push({Score, std::move(Info)});
   });
   for (auto &R : std::move(Top).items())
     Result.push_back(std::move(R.second));
   return Result;

clang-tools-extra/clangd/Quality.h

enum SymbolCategory {
     Namespace,
     Keyword,
     Operator,
   } Category = Unknown;
 
   void merge(const CodeCompletionResult &SemaCCResult);
   void merge(const Symbol &IndexResult);
 
-  // FIXME(usx): Rename to evaluateHeuristics().
   // Condense these signals down to a single number, higher is better.
-  float evaluate() const;
+  float evaluateHeuristics() const;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &,
                               const SymbolQualitySignals &);
 
 /// Attributes of a symbol-query pair that affect how much we like it.
 struct SymbolRelevanceSignals {
   /// The name of the symbol (for ContextWords). Must be explicitly assigned.
   llvm::StringRef Name;
struct SymbolRelevanceSignals {
   };
 
   DerivedSignals calculateDerivedSignals() const;
 
   void merge(const CodeCompletionResult &SemaResult);
   void merge(const Symbol &IndexResult);
 
   // Condense these signals down to a single number, higher is better.
-  float evaluate() const;
+  float evaluateHeuristics() const;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &,
                               const SymbolRelevanceSignals &);
 
 /// Combine symbol quality and relevance into a single score.
 float evaluateSymbolAndRelevance(float SymbolQuality, float SymbolRelevance);
 
 float evaluateDecisionForest(const SymbolQualitySignals &Quality,

clang-tools-extra/clangd/Quality.cpp

 void SymbolQualitySignals::merge(const Symbol &IndexResult) {
   Deprecated |= (IndexResult.Flags & Symbol::Deprecated);
   ImplementationDetail |= (IndexResult.Flags & Symbol::ImplementationDetail);
   References = std::max(IndexResult.References, References);
   Category = categorize(IndexResult.SymInfo);
   ReservedName = ReservedName || isReserved(IndexResult.Name);
 }
 
-float SymbolQualitySignals::evaluate() const {
+float SymbolQualitySignals::evaluateHeuristics() const {
   float Score = 1;
 
   // This avoids a sharp gradient for tail symbols, and also neatly avoids the
   // question of whether 0 references means a bad symbol or missing data.
   if (References >= 10) {
     // Use a sigmoid style boosting function, which flats out nicely for large
     // numbers (e.g. 2.58 for 1M references).
     // The following boosting function is equivalent to:
case Unknown:
     break;
   }
 
   return Score;
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                               const SymbolQualitySignals &S) {
-  OS << llvm::formatv("=== Symbol quality: {0}\n", S.evaluate());
+  OS << llvm::formatv("=== Symbol quality: {0}\n", S.evaluateHeuristics());
   OS << llvm::formatv("\tReferences: {0}\n", S.References);
   OS << llvm::formatv("\tDeprecated: {0}\n", S.Deprecated);
   OS << llvm::formatv("\tReserved name: {0}\n", S.ReservedName);
   OS << llvm::formatv("\tCategory: {0}\n", static_cast<int>(S.Category));
   return OS;
 }
 
 static SymbolRelevanceSignals::AccessibleScope
SymbolRelevanceSignals::calculateDerivedSignals() const {
   if (ScopeProximityMatch) {
     // For global symbol, the distance is 0.
     Derived.ScopeProximityDistance =
         SymbolScope ? ScopeProximityMatch->distance(*SymbolScope) : 0;
   }
   return Derived;
 }
 
-float SymbolRelevanceSignals::evaluate() const {
+float SymbolRelevanceSignals::evaluateHeuristics() const {
   DerivedSignals Derived = calculateDerivedSignals();
   float Score = 1;
 
   if (Forbidden)
     return 0;
 
   Score *= NameMatch;
 
float SymbolRelevanceSignals::evaluateHeuristics() const {
   if (NeedsFixIts)
     Score *= 0.5f;
 
   return Score;
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                               const SymbolRelevanceSignals &S) {
-  OS << llvm::formatv("=== Symbol relevance: {0}\n", S.evaluate());
+  OS << llvm::formatv("=== Symbol relevance: {0}\n", S.evaluateHeuristics());
   OS << llvm::formatv("\tName: {0}\n", S.Name);
   OS << llvm::formatv("\tName match: {0}\n", S.NameMatch);
   if (S.ContextWords)
     OS << llvm::formatv(
         "\tMatching context word: {0}\n",
         wordMatching(S.Name, S.ContextWords).getValueOr("<none>"));
   OS << llvm::formatv("\tForbidden: {0}\n", S.Forbidden);
   OS << llvm::formatv("\tNeedsFixIts: {0}\n", S.NeedsFixIts);

clang-tools-extra/clangd/XRefs.cpp

Index->fuzzyFind(Req, [&](const Symbol &Sym) {
     }
 
     SymbolQualitySignals Quality;
     Quality.merge(Sym);
     SymbolRelevanceSignals Relevance;
     Relevance.Name = Sym.Name;
     Relevance.Query = SymbolRelevanceSignals::Generic;
     Relevance.merge(Sym);
-    auto Score =
-        evaluateSymbolAndRelevance(Quality.evaluate(), Relevance.evaluate());
+    auto Score = evaluateSymbolAndRelevance(Quality.evaluateHeuristics(),
+                                            Relevance.evaluateHeuristics());
     dlog("locateSymbolNamedTextuallyAt: {0}{1} = {2}\n{3}{4}\n", Sym.Scope,
          Sym.Name, Score, Quality, Relevance);
 
     ScoredResults.push_back({Score, std::move(Located)});
   });
 
   if (TooMany) {
     vlog("Heuristic index lookup for {0} returned too many candidates, ignored",

clang-tools-extra/clangd/index/dex/Dex.cpp

std::unique_ptr<Iterator> Dex::createFileProximityIterator(
   // Try to build BOOST iterator for each Proximity Path provided by
   // ProximityPaths. Boosting factor should depend on the distance to the
   // Proximity Path: the closer processed path is, the higher boosting factor.
   for (const auto &ParentURI : ParentURIs.keys()) {
     // FIXME(kbobyrev): Append LIMIT on top of every BOOST iterator.
     auto It = iterator(Token(Token::Kind::ProximityURI, ParentURI));
     if (It->kind() != Iterator::Kind::False) {
       PathProximitySignals.SymbolURI = ParentURI;
-      BoostingIterators.push_back(
-          Corpus.boost(std::move(It), PathProximitySignals.evaluate()));
+      BoostingIterators.push_back(Corpus.boost(
+          std::move(It), PathProximitySignals.evaluateHeuristics()));
     }
   }
   BoostingIterators.push_back(Corpus.all());
   return Corpus.unionOf(std::move(BoostingIterators));
 }
 
 // Constructs BOOST iterators for preferred types.
 std::unique_ptr<Iterator>
 Dex::createTypeBoostingIterator(llvm::ArrayRef<std::string> Types) const {
   std::vector<std::unique_ptr<Iterator>> BoostingIterators;
   SymbolRelevanceSignals PreferredTypeSignals;
   PreferredTypeSignals.TypeMatchesPreferred = true;
-  auto Boost = PreferredTypeSignals.evaluate();
+  auto Boost = PreferredTypeSignals.evaluateHeuristics();
   for (const auto &T : Types)
     BoostingIterators.push_back(
         Corpus.boost(iterator(Token(Token::Kind::Type, T)), Boost));
   BoostingIterators.push_back(Corpus.all());
   return Corpus.unionOf(std::move(BoostingIterators));
 }
 
 /// Constructs iterators over tokens extracted from the query and exhausts it

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

Index->fuzzyFind(Req, [&](const Symbol &S) {
     EXPECT_EQ(Relevance.Scope, SymbolRelevanceSignals::FileScope);
   });
   EXPECT_TRUE(Matched);
 }
 
 // Do the signals move the scores in the direction we expect?
 TEST(QualityTests, SymbolQualitySignalsSanity) {
   SymbolQualitySignals Default;
-  EXPECT_EQ(Default.evaluate(), 1);
+  EXPECT_EQ(Default.evaluateHeuristics(), 1);
 
   SymbolQualitySignals Deprecated;
   Deprecated.Deprecated = true;
-  EXPECT_LT(Deprecated.evaluate(), Default.evaluate());
+  EXPECT_LT(Deprecated.evaluateHeuristics(), Default.evaluateHeuristics());
 
   SymbolQualitySignals ReservedName;
   ReservedName.ReservedName = true;
-  EXPECT_LT(ReservedName.evaluate(), Default.evaluate());
+  EXPECT_LT(ReservedName.evaluateHeuristics(), Default.evaluateHeuristics());
 
   SymbolQualitySignals ImplementationDetail;
   ImplementationDetail.ImplementationDetail = true;
-  EXPECT_LT(ImplementationDetail.evaluate(), Default.evaluate());
+  EXPECT_LT(ImplementationDetail.evaluateHeuristics(),
+            Default.evaluateHeuristics());
 
   SymbolQualitySignals WithReferences, ManyReferences;
   WithReferences.References = 20;
   ManyReferences.References = 1000;
-  EXPECT_GT(WithReferences.evaluate(), Default.evaluate());
-  EXPECT_GT(ManyReferences.evaluate(), WithReferences.evaluate());
+  EXPECT_GT(WithReferences.evaluateHeuristics(), Default.evaluateHeuristics());
+  EXPECT_GT(ManyReferences.evaluateHeuristics(),
+            WithReferences.evaluateHeuristics());
 
   SymbolQualitySignals Keyword, Variable, Macro, Constructor, Function,
       Destructor, Operator;
   Keyword.Category = SymbolQualitySignals::Keyword;
   Variable.Category = SymbolQualitySignals::Variable;
   Macro.Category = SymbolQualitySignals::Macro;
   Constructor.Category = SymbolQualitySignals::Constructor;
   Destructor.Category = SymbolQualitySignals::Destructor;
   Destructor.Category = SymbolQualitySignals::Destructor;
   Operator.Category = SymbolQualitySignals::Operator;
   Function.Category = SymbolQualitySignals::Function;
-  EXPECT_GT(Variable.evaluate(), Default.evaluate());
-  EXPECT_GT(Keyword.evaluate(), Variable.evaluate());
-  EXPECT_LT(Macro.evaluate(), Default.evaluate());
-  EXPECT_LT(Operator.evaluate(), Default.evaluate());
-  EXPECT_LT(Constructor.evaluate(), Function.evaluate());
-  EXPECT_LT(Destructor.evaluate(), Constructor.evaluate());
+  EXPECT_GT(Variable.evaluateHeuristics(), Default.evaluateHeuristics());
+  EXPECT_GT(Keyword.evaluateHeuristics(), Variable.evaluateHeuristics());
+  EXPECT_LT(Macro.evaluateHeuristics(), Default.evaluateHeuristics());
+  EXPECT_LT(Operator.evaluateHeuristics(), Default.evaluateHeuristics());
+  EXPECT_LT(Constructor.evaluateHeuristics(), Function.evaluateHeuristics());
+  EXPECT_LT(Destructor.evaluateHeuristics(), Constructor.evaluateHeuristics());
 }
 
 TEST(QualityTests, SymbolRelevanceSignalsSanity) {
   SymbolRelevanceSignals Default;
-  EXPECT_EQ(Default.evaluate(), 1);
+  EXPECT_EQ(Default.evaluateHeuristics(), 1);
 
   SymbolRelevanceSignals Forbidden;
   Forbidden.Forbidden = true;
-  EXPECT_LT(Forbidden.evaluate(), Default.evaluate());
+  EXPECT_LT(Forbidden.evaluateHeuristics(), Default.evaluateHeuristics());
 
   SymbolRelevanceSignals PoorNameMatch;
   PoorNameMatch.NameMatch = 0.2f;
-  EXPECT_LT(PoorNameMatch.evaluate(), Default.evaluate());
+  EXPECT_LT(PoorNameMatch.evaluateHeuristics(), Default.evaluateHeuristics());
 
   SymbolRelevanceSignals WithSemaFileProximity;
   WithSemaFileProximity.SemaFileProximityScore = 0.2f;
-  EXPECT_GT(WithSemaFileProximity.evaluate(), Default.evaluate());
+  EXPECT_GT(WithSemaFileProximity.evaluateHeuristics(),
+            Default.evaluateHeuristics());
 
   ScopeDistance ScopeProximity({"x::y::"});
 
   SymbolRelevanceSignals WithSemaScopeProximity;
   WithSemaScopeProximity.ScopeProximityMatch = &ScopeProximity;
   WithSemaScopeProximity.SemaSaysInScope = true;
-  EXPECT_GT(WithSemaScopeProximity.evaluate(), Default.evaluate());
+  EXPECT_GT(WithSemaScopeProximity.evaluateHeuristics(),
+            Default.evaluateHeuristics());
 
   SymbolRelevanceSignals WithIndexScopeProximity;
   WithIndexScopeProximity.ScopeProximityMatch = &ScopeProximity;
   WithIndexScopeProximity.SymbolScope = "x::";
-  EXPECT_GT(WithSemaScopeProximity.evaluate(), Default.evaluate());
+  EXPECT_GT(WithSemaScopeProximity.evaluateHeuristics(),
+            Default.evaluateHeuristics());
 
   SymbolRelevanceSignals IndexProximate;
   IndexProximate.SymbolURI = "unittest:/foo/bar.h";
   llvm::StringMap<SourceParams> ProxSources;
   ProxSources.try_emplace(testPath("foo/baz.h"));
   URIDistance Distance(ProxSources);
   IndexProximate.FileProximityMatch = &Distance;
-  EXPECT_GT(IndexProximate.evaluate(), Default.evaluate());
+  EXPECT_GT(IndexProximate.evaluateHeuristics(), Default.evaluateHeuristics());
   SymbolRelevanceSignals IndexDistant = IndexProximate;
   IndexDistant.SymbolURI = "unittest:/elsewhere/path.h";
-  EXPECT_GT(IndexProximate.evaluate(), IndexDistant.evaluate())
+  EXPECT_GT(IndexProximate.evaluateHeuristics(),
+            IndexDistant.evaluateHeuristics())
       << IndexProximate << IndexDistant;
-  EXPECT_GT(IndexDistant.evaluate(), Default.evaluate());
+  EXPECT_GT(IndexDistant.evaluateHeuristics(), Default.evaluateHeuristics());
 
   SymbolRelevanceSignals Scoped;
   Scoped.Scope = SymbolRelevanceSignals::FileScope;
-  EXPECT_LT(Scoped.evaluate(), Default.evaluate());
+  EXPECT_LT(Scoped.evaluateHeuristics(), Default.evaluateHeuristics());
   Scoped.Query = SymbolRelevanceSignals::CodeComplete;
-  EXPECT_GT(Scoped.evaluate(), Default.evaluate());
+  EXPECT_GT(Scoped.evaluateHeuristics(), Default.evaluateHeuristics());
 
   SymbolRelevanceSignals Instance;
   Instance.IsInstanceMember = false;
-  EXPECT_EQ(Instance.evaluate(), Default.evaluate());
+  EXPECT_EQ(Instance.evaluateHeuristics(), Default.evaluateHeuristics());
   Instance.Context = CodeCompletionContext::CCC_DotMemberAccess;
-  EXPECT_LT(Instance.evaluate(), Default.evaluate());
+  EXPECT_LT(Instance.evaluateHeuristics(), Default.evaluateHeuristics());
   Instance.IsInstanceMember = true;
-  EXPECT_EQ(Instance.evaluate(), Default.evaluate());
+  EXPECT_EQ(Instance.evaluateHeuristics(), Default.evaluateHeuristics());
 
   SymbolRelevanceSignals InBaseClass;
   InBaseClass.InBaseClass = true;
-  EXPECT_LT(InBaseClass.evaluate(), Default.evaluate());
+  EXPECT_LT(InBaseClass.evaluateHeuristics(), Default.evaluateHeuristics());
 
   llvm::StringSet<> Words = {"one", "two", "three"};
   SymbolRelevanceSignals WithoutMatchingWord;
   WithoutMatchingWord.ContextWords = &Words;
   WithoutMatchingWord.Name = "four";
-  EXPECT_EQ(WithoutMatchingWord.evaluate(), Default.evaluate());
+  EXPECT_EQ(WithoutMatchingWord.evaluateHeuristics(),
+            Default.evaluateHeuristics());
   SymbolRelevanceSignals WithMatchingWord;
   WithMatchingWord.ContextWords = &Words;
   WithMatchingWord.Name = "TheTwoTowers";
-  EXPECT_GT(WithMatchingWord.evaluate(), Default.evaluate());
+  EXPECT_GT(WithMatchingWord.evaluateHeuristics(),
+            Default.evaluateHeuristics());
 }
 
 TEST(QualityTests, ScopeProximity) {
   SymbolRelevanceSignals Relevance;
   ScopeDistance ScopeProximity({"x::y::z::", "x::", "llvm::", ""});
   Relevance.ScopeProximityMatch = &ScopeProximity;
 
   Relevance.SymbolScope = "other::";
-  float NotMatched = Relevance.evaluate();
+  float NotMatched = Relevance.evaluateHeuristics();
 
   Relevance.SymbolScope = "";
-  float Global = Relevance.evaluate();
+  float Global = Relevance.evaluateHeuristics();
   EXPECT_GT(Global, NotMatched);
 
   Relevance.SymbolScope = "llvm::";
-  float NonParent = Relevance.evaluate();
+  float NonParent = Relevance.evaluateHeuristics();
   EXPECT_GT(NonParent, Global);
 
   Relevance.SymbolScope = "x::";
-  float GrandParent = Relevance.evaluate();
+  float GrandParent = Relevance.evaluateHeuristics();
   EXPECT_GT(GrandParent, Global);
 
   Relevance.SymbolScope = "x::y::";
-  float Parent = Relevance.evaluate();
+  float Parent = Relevance.evaluateHeuristics();
   EXPECT_GT(Parent, GrandParent);
 
   Relevance.SymbolScope = "x::y::z::";
-  float Enclosing = Relevance.evaluate();
+  float Enclosing = Relevance.evaluateHeuristics();
   EXPECT_GT(Enclosing, Parent);
 }
 
 TEST(QualityTests, SortText) {
   EXPECT_LT(sortText(std::numeric_limits<float>::infinity()),
             sortText(1000.2f));
   EXPECT_LT(sortText(1000.2f), sortText(1));
   EXPECT_LT(sortText(1), sortText(0.3f));
RelevanceWithFixIt.merge(CodeCompletionResult(&findDecl(AST, "x"), 0, nullptr,
                                                 false, true, {FixItHint{}}));
   EXPECT_TRUE(RelevanceWithFixIt.NeedsFixIts);
 
   SymbolRelevanceSignals RelevanceWithoutFixIt;
   RelevanceWithoutFixIt.merge(
       CodeCompletionResult(&findDecl(AST, "x"), 0, nullptr, false, true, {}));
   EXPECT_FALSE(RelevanceWithoutFixIt.NeedsFixIts);
 
-  EXPECT_LT(RelevanceWithFixIt.evaluate(), RelevanceWithoutFixIt.evaluate());
+  EXPECT_LT(RelevanceWithFixIt.evaluateHeuristics(),
+            RelevanceWithoutFixIt.evaluateHeuristics());
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang