[clangd] Use a sigmoid style function for #usages boost in symbol quality.

[ioeric]

Summary

This has a shape to similar logrithm function but grows much slower for
large #usages.

Metrics: https://reviews.llvm.org/P8096

[ilya-biryukov]

Overall LG. I'm sure it's an improvement overall, just wanted to get some clarifying comments and references, if that's possible.

NIT: a typo in the commit message
s/logrithm/logarithm

clangd/Quality.cpp

200

Made add references or intuition on why this boosting function is good?
Also on why can't we use the original boost function and need to simplify it?

203

Any reason to not use std::pow(References, -0.06) instead?
(not a suggestion to actually change the code, just wondering if there are any reasons (apart from personal preferences) to prefer one over the other)

[ioeric]

Addressed review comments.

[ioeric]

clangd/Quality.cpp

200

Turned out "simplification" might be the wrong word. Improved the comment a bit.

203

Nope, no particular reason. Positive exponent looks a bit nicer in formula, but I think it's fine here. Switched to std::pow(References, -0.06).

[ilya-biryukov]

LGTM

clangd/Quality.cpp

194

NIT: better, but nothing to compare to in the comment.
Maybe use "better than log" or "nicely" instead?

[ioeric]

s/better/nicely/

clangd/Quality.cpp

void SymbolQualitySignals::merge(const Symbol &IndexResult) {
   ReservedName = ReservedName || IsReserved(IndexResult.Name);
 }
 
 float SymbolQualitySignals::evaluate() 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)
-    Score *= std::log10(References);
+  if (References >= 10) {
+    // Use a sigmoid style boosting function, which flats out nicely for large
+    // numbers (e.g. 2.58 for 1M refererences).
+    // The following boosting function is equivalent to:
+    //   m = 0.06
+    //   f = 12.0
+    //   boost = f * sigmoid(m * std::log(References)) - 0.5 * f + 0.59
+    // Sample data points: (10, 1.00), (100, 1.41), (1000, 1.82),
+    //                     (10K, 2.21), (100K, 2.58), (1M, 2.94)
+    float s = std::pow(References, -0.06);
+    Score *= 6.0 * (1 - s) / (1 + s) + 0.59;
+  }
 
   if (Deprecated)
     Score *= 0.1f;
   if (ReservedName)
     Score *= 0.1f;
 
   switch (Category) {
   case Keyword: // Often relevant, but misses most signals.

unittests/clangd/CodeCompleteTests.cpp

auto Results = completions(
       R"cpp(
           void f() { ns::x^ }
       )cpp",
       {cls("ns::XYZ"), func("ns::foo")});
   EXPECT_THAT(Results.Completions, UnorderedElementsAre(Named("XYZ")));
 }
 
 TEST(CompletionTest, ReferencesAffectRanking) {
-  auto Results = completions("int main() { abs^ }", {ns("absl"), func("abs")});
-  EXPECT_THAT(Results.Completions, HasSubsequence(Named("abs"), Named("absl")));
+  auto Results = completions("int main() { abs^ }", {ns("absl"), func("absb")});
+  EXPECT_THAT(Results.Completions, HasSubsequence(Named("absb"), Named("absl")));
   Results = completions("int main() { abs^ }",
-                        {withReferences(10000, ns("absl")), func("abs")});
-  EXPECT_THAT(Results.Completions, HasSubsequence(Named("absl"), Named("abs")));
+                        {withReferences(10000, ns("absl")), func("absb")});
+  EXPECT_THAT(Results.Completions,
+              HasSubsequence(Named("absl"), Named("absb")));
 }
 
 TEST(CompletionTest, GlobalQualified) {
   auto Results = completions(
       R"cpp(
           void f() { ::^ }
       )cpp",
       {cls("XYZ")});