llvm-project

1
//===--- Quality.cpp ---------------------------------------------*- C++-*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8

9
#include "Quality.h"
10
#include "AST.h"
11
#include "ASTSignals.h"
12
#include "FileDistance.h"
13
#include "SourceCode.h"
14
#include "index/Symbol.h"
15
#include "clang/AST/ASTContext.h"
16
#include "clang/AST/Decl.h"
17
#include "clang/AST/DeclCXX.h"
18
#include "clang/AST/DeclTemplate.h"
19
#include "clang/AST/DeclVisitor.h"
20
#include "clang/Basic/SourceManager.h"
21
#include "clang/Sema/CodeCompleteConsumer.h"
22
#include "llvm/ADT/StringRef.h"
23
#include "llvm/Support/Casting.h"
24
#include "llvm/Support/FormatVariadic.h"
25
#include "llvm/Support/MathExtras.h"
26
#include "llvm/Support/raw_ostream.h"
27
#include <algorithm>
28
#include <cmath>
29
#include <optional>
30

31
namespace clang {
32
namespace clangd {
33

34
static bool hasDeclInMainFile(const Decl &D) {
35
  auto &SourceMgr = D.getASTContext().getSourceManager();
36
  for (auto *Redecl : D.redecls()) {
37
    if (isInsideMainFile(Redecl->getLocation(), SourceMgr))
38
      return true;
39
  }
40
  return false;
41
}
42

43
static bool hasUsingDeclInMainFile(const CodeCompletionResult &R) {
44
  const auto &Context = R.Declaration->getASTContext();
45
  const auto &SourceMgr = Context.getSourceManager();
46
  if (R.ShadowDecl) {
47
    if (isInsideMainFile(R.ShadowDecl->getLocation(), SourceMgr))
48
      return true;
49
  }
50
  return false;
51
}
52

53
static SymbolQualitySignals::SymbolCategory categorize(const NamedDecl &ND) {
54
  if (const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
55
    if (FD->isOverloadedOperator())
56
      return SymbolQualitySignals::Operator;
57
  }
58
  class Switch
59
      : public ConstDeclVisitor<Switch, SymbolQualitySignals::SymbolCategory> {
60
  public:
61
#define MAP(DeclType, Category)                                                \
62
  SymbolQualitySignals::SymbolCategory Visit##DeclType(const DeclType *) {     \
63
    return SymbolQualitySignals::Category;                                     \
64
  }
65
    MAP(NamespaceDecl, Namespace);
66
    MAP(NamespaceAliasDecl, Namespace);
67
    MAP(TypeDecl, Type);
68
    MAP(TypeAliasTemplateDecl, Type);
69
    MAP(ClassTemplateDecl, Type);
70
    MAP(CXXConstructorDecl, Constructor);
71
    MAP(CXXDestructorDecl, Destructor);
72
    MAP(ValueDecl, Variable);
73
    MAP(VarTemplateDecl, Variable);
74
    MAP(FunctionDecl, Function);
75
    MAP(FunctionTemplateDecl, Function);
76
    MAP(Decl, Unknown);
77
#undef MAP
78
  };
79
  return Switch().Visit(&ND);
80
}
81

82
static SymbolQualitySignals::SymbolCategory
83
categorize(const CodeCompletionResult &R) {
84
  if (R.Declaration)
85
    return categorize(*R.Declaration);
86
  if (R.Kind == CodeCompletionResult::RK_Macro)
87
    return SymbolQualitySignals::Macro;
88
  // Everything else is a keyword or a pattern. Patterns are mostly keywords
89
  // too, except a few which we recognize by cursor kind.
90
  switch (R.CursorKind) {
91
  case CXCursor_CXXMethod:
92
    return SymbolQualitySignals::Function;
93
  case CXCursor_ModuleImportDecl:
94
    return SymbolQualitySignals::Namespace;
95
  case CXCursor_MacroDefinition:
96
    return SymbolQualitySignals::Macro;
97
  case CXCursor_TypeRef:
98
    return SymbolQualitySignals::Type;
99
  case CXCursor_MemberRef:
100
    return SymbolQualitySignals::Variable;
101
  case CXCursor_Constructor:
102
    return SymbolQualitySignals::Constructor;
103
  default:
104
    return SymbolQualitySignals::Keyword;
105
  }
106
}
107

108
static SymbolQualitySignals::SymbolCategory
109
categorize(const index::SymbolInfo &D) {
110
  switch (D.Kind) {
111
  case index::SymbolKind::Namespace:
112
  case index::SymbolKind::NamespaceAlias:
113
    return SymbolQualitySignals::Namespace;
114
  case index::SymbolKind::Macro:
115
    return SymbolQualitySignals::Macro;
116
  case index::SymbolKind::Enum:
117
  case index::SymbolKind::Struct:
118
  case index::SymbolKind::Class:
119
  case index::SymbolKind::Protocol:
120
  case index::SymbolKind::Extension:
121
  case index::SymbolKind::Union:
122
  case index::SymbolKind::TypeAlias:
123
  case index::SymbolKind::TemplateTypeParm:
124
  case index::SymbolKind::TemplateTemplateParm:
125
  case index::SymbolKind::Concept:
126
    return SymbolQualitySignals::Type;
127
  case index::SymbolKind::Function:
128
  case index::SymbolKind::ClassMethod:
129
  case index::SymbolKind::InstanceMethod:
130
  case index::SymbolKind::StaticMethod:
131
  case index::SymbolKind::InstanceProperty:
132
  case index::SymbolKind::ClassProperty:
133
  case index::SymbolKind::StaticProperty:
134
  case index::SymbolKind::ConversionFunction:
135
    return SymbolQualitySignals::Function;
136
  case index::SymbolKind::Destructor:
137
    return SymbolQualitySignals::Destructor;
138
  case index::SymbolKind::Constructor:
139
    return SymbolQualitySignals::Constructor;
140
  case index::SymbolKind::Variable:
141
  case index::SymbolKind::Field:
142
  case index::SymbolKind::EnumConstant:
143
  case index::SymbolKind::Parameter:
144
  case index::SymbolKind::NonTypeTemplateParm:
145
    return SymbolQualitySignals::Variable;
146
  case index::SymbolKind::Using:
147
  case index::SymbolKind::Module:
148
  case index::SymbolKind::Unknown:
149
    return SymbolQualitySignals::Unknown;
150
  }
151
  llvm_unreachable("Unknown index::SymbolKind");
152
}
153

154
static bool isInstanceMember(const NamedDecl *ND) {
155
  if (!ND)
156
    return false;
157
  if (const auto *TP = dyn_cast<FunctionTemplateDecl>(ND))
158
    ND = TP->TemplateDecl::getTemplatedDecl();
159
  if (const auto *CM = dyn_cast<CXXMethodDecl>(ND))
160
    return !CM->isStatic();
161
  return isa<FieldDecl>(ND); // Note that static fields are VarDecl.
162
}
163

164
static bool isInstanceMember(const index::SymbolInfo &D) {
165
  switch (D.Kind) {
166
  case index::SymbolKind::InstanceMethod:
167
  case index::SymbolKind::InstanceProperty:
168
  case index::SymbolKind::Field:
169
    return true;
170
  default:
171
    return false;
172
  }
173
}
174

175
void SymbolQualitySignals::merge(const CodeCompletionResult &SemaCCResult) {
176
  Deprecated |= (SemaCCResult.Availability == CXAvailability_Deprecated);
177
  Category = categorize(SemaCCResult);
178

179
  if (SemaCCResult.Declaration) {
180
    ImplementationDetail |= isImplementationDetail(SemaCCResult.Declaration);
181
    if (auto *ID = SemaCCResult.Declaration->getIdentifier())
182
      ReservedName = ReservedName || isReservedName(ID->getName());
183
  } else if (SemaCCResult.Kind == CodeCompletionResult::RK_Macro)
184
    ReservedName =
185
        ReservedName || isReservedName(SemaCCResult.Macro->getName());
186
}
187

188
void SymbolQualitySignals::merge(const Symbol &IndexResult) {
189
  Deprecated |= (IndexResult.Flags & Symbol::Deprecated);
190
  ImplementationDetail |= (IndexResult.Flags & Symbol::ImplementationDetail);
191
  References = std::max(IndexResult.References, References);
192
  Category = categorize(IndexResult.SymInfo);
193
  ReservedName = ReservedName || isReservedName(IndexResult.Name);
194
}
195

196
float SymbolQualitySignals::evaluateHeuristics() const {
197
  float Score = 1;
198

199
  // This avoids a sharp gradient for tail symbols, and also neatly avoids the
200
  // question of whether 0 references means a bad symbol or missing data.
201
  if (References >= 10) {
202
    // Use a sigmoid style boosting function, which flats out nicely for large
203
    // numbers (e.g. 2.58 for 1M references).
204
    // The following boosting function is equivalent to:
205
    //   m = 0.06
206
    //   f = 12.0
207
    //   boost = f * sigmoid(m * std::log(References)) - 0.5 * f + 0.59
208
    // Sample data points: (10, 1.00), (100, 1.41), (1000, 1.82),
209
    //                     (10K, 2.21), (100K, 2.58), (1M, 2.94)
210
    float S = std::pow(References, -0.06);
211
    Score *= 6.0 * (1 - S) / (1 + S) + 0.59;
212
  }
213

214
  if (Deprecated)
215
    Score *= 0.1f;
216
  if (ReservedName)
217
    Score *= 0.1f;
218
  if (ImplementationDetail)
219
    Score *= 0.2f;
220

221
  switch (Category) {
222
  case Keyword: // Often relevant, but misses most signals.
223
    Score *= 4; // FIXME: important keywords should have specific boosts.
224
    break;
225
  case Type:
226
  case Function:
227
  case Variable:
228
    Score *= 1.1f;
229
    break;
230
  case Namespace:
231
    Score *= 0.8f;
232
    break;
233
  case Macro:
234
  case Destructor:
235
  case Operator:
236
    Score *= 0.5f;
237
    break;
238
  case Constructor: // No boost constructors so they are after class types.
239
  case Unknown:
240
    break;
241
  }
242

243
  return Score;
244
}
245

246
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
247
                              const SymbolQualitySignals &S) {
248
  OS << llvm::formatv("=== Symbol quality: {0}\n", S.evaluateHeuristics());
249
  OS << llvm::formatv("\tReferences: {0}\n", S.References);
250
  OS << llvm::formatv("\tDeprecated: {0}\n", S.Deprecated);
251
  OS << llvm::formatv("\tReserved name: {0}\n", S.ReservedName);
252
  OS << llvm::formatv("\tImplementation detail: {0}\n", S.ImplementationDetail);
253
  OS << llvm::formatv("\tCategory: {0}\n", static_cast<int>(S.Category));
254
  return OS;
255
}
256

257
static SymbolRelevanceSignals::AccessibleScope
258
computeScope(const NamedDecl *D) {
259
  // Injected "Foo" within the class "Foo" has file scope, not class scope.
260
  const DeclContext *DC = D->getDeclContext();
261
  if (auto *R = dyn_cast_or_null<RecordDecl>(D))
262
    if (R->isInjectedClassName())
263
      DC = DC->getParent();
264
  // Class constructor should have the same scope as the class.
265
  if (isa<CXXConstructorDecl>(D))
266
    DC = DC->getParent();
267
  bool InClass = false;
268
  for (; !DC->isFileContext(); DC = DC->getParent()) {
269
    if (DC->isFunctionOrMethod())
270
      return SymbolRelevanceSignals::FunctionScope;
271
    InClass = InClass || DC->isRecord();
272
  }
273
  if (InClass)
274
    return SymbolRelevanceSignals::ClassScope;
275
  // ExternalLinkage threshold could be tweaked, e.g. module-visible as global.
276
  // Avoid caching linkage if it may change after enclosing code completion.
277
  if (hasUnstableLinkage(D) || llvm::to_underlying(D->getLinkageInternal()) <
278
                                   llvm::to_underlying(Linkage::External))
279
    return SymbolRelevanceSignals::FileScope;
280
  return SymbolRelevanceSignals::GlobalScope;
281
}
282

283
void SymbolRelevanceSignals::merge(const Symbol &IndexResult) {
284
  SymbolURI = IndexResult.CanonicalDeclaration.FileURI;
285
  SymbolScope = IndexResult.Scope;
286
  IsInstanceMember |= isInstanceMember(IndexResult.SymInfo);
287
  if (!(IndexResult.Flags & Symbol::VisibleOutsideFile)) {
288
    Scope = AccessibleScope::FileScope;
289
  }
290
  if (MainFileSignals) {
291
    MainFileRefs =
292
        std::max(MainFileRefs,
293
                 MainFileSignals->ReferencedSymbols.lookup(IndexResult.ID));
294
    ScopeRefsInFile =
295
        std::max(ScopeRefsInFile,
296
                 MainFileSignals->RelatedNamespaces.lookup(IndexResult.Scope));
297
  }
298
}
299

300
void SymbolRelevanceSignals::computeASTSignals(
301
    const CodeCompletionResult &SemaResult) {
302
  if (!MainFileSignals)
303
    return;
304
  if ((SemaResult.Kind != CodeCompletionResult::RK_Declaration) &&
305
      (SemaResult.Kind != CodeCompletionResult::RK_Pattern))
306
    return;
307
  if (const NamedDecl *ND = SemaResult.getDeclaration()) {
308
    if (hasUnstableLinkage(ND))
309
      return;
310
    auto ID = getSymbolID(ND);
311
    if (!ID)
312
      return;
313
    MainFileRefs =
314
        std::max(MainFileRefs, MainFileSignals->ReferencedSymbols.lookup(ID));
315
    if (const auto *NSD = dyn_cast<NamespaceDecl>(ND->getDeclContext())) {
316
      if (NSD->isAnonymousNamespace())
317
        return;
318
      std::string Scope = printNamespaceScope(*NSD);
319
      if (!Scope.empty())
320
        ScopeRefsInFile = std::max(
321
            ScopeRefsInFile, MainFileSignals->RelatedNamespaces.lookup(Scope));
322
    }
323
  }
324
}
325

326
void SymbolRelevanceSignals::merge(const CodeCompletionResult &SemaCCResult) {
327
  if (SemaCCResult.Availability == CXAvailability_NotAvailable ||
328
      SemaCCResult.Availability == CXAvailability_NotAccessible)
329
    Forbidden = true;
330

331
  if (SemaCCResult.Declaration) {
332
    SemaSaysInScope = true;
333
    // We boost things that have decls in the main file. We give a fixed score
334
    // for all other declarations in sema as they are already included in the
335
    // translation unit.
336
    float DeclProximity = (hasDeclInMainFile(*SemaCCResult.Declaration) ||
337
                           hasUsingDeclInMainFile(SemaCCResult))
338
                              ? 1.0
339
                              : 0.6;
340
    SemaFileProximityScore = std::max(DeclProximity, SemaFileProximityScore);
341
    IsInstanceMember |= isInstanceMember(SemaCCResult.Declaration);
342
    InBaseClass |= SemaCCResult.InBaseClass;
343
  }
344

345
  computeASTSignals(SemaCCResult);
346
  // Declarations are scoped, others (like macros) are assumed global.
347
  if (SemaCCResult.Declaration)
348
    Scope = std::min(Scope, computeScope(SemaCCResult.Declaration));
349

350
  NeedsFixIts = !SemaCCResult.FixIts.empty();
351
}
352

353
static float fileProximityScore(unsigned FileDistance) {
354
  // Range: [0, 1]
355
  // FileDistance = [0, 1, 2, 3, 4, .., FileDistance::Unreachable]
356
  // Score = [1, 0.82, 0.67, 0.55, 0.45, .., 0]
357
  if (FileDistance == FileDistance::Unreachable)
358
    return 0;
359
  // Assume approximately default options are used for sensible scoring.
360
  return std::exp(FileDistance * -0.4f / FileDistanceOptions().UpCost);
361
}
362

363
static float scopeProximityScore(unsigned ScopeDistance) {
364
  // Range: [0.6, 2].
365
  // ScopeDistance = [0, 1, 2, 3, 4, 5, 6, 7, .., FileDistance::Unreachable]
366
  // Score = [2.0, 1.55, 1.2, 0.93, 0.72, 0.65, 0.65, 0.65, .., 0.6]
367
  if (ScopeDistance == FileDistance::Unreachable)
368
    return 0.6f;
369
  return std::max(0.65, 2.0 * std::pow(0.6, ScopeDistance / 2.0));
370
}
371

372
static std::optional<llvm::StringRef>
373
wordMatching(llvm::StringRef Name, const llvm::StringSet<> *ContextWords) {
374
  if (ContextWords)
375
    for (const auto &Word : ContextWords->keys())
376
      if (Name.contains_insensitive(Word))
377
        return Word;
378
  return std::nullopt;
379
}
380

381
SymbolRelevanceSignals::DerivedSignals
382
SymbolRelevanceSignals::calculateDerivedSignals() const {
383
  DerivedSignals Derived;
384
  Derived.NameMatchesContext = wordMatching(Name, ContextWords).has_value();
385
  Derived.FileProximityDistance = !FileProximityMatch || SymbolURI.empty()
386
                                      ? FileDistance::Unreachable
387
                                      : FileProximityMatch->distance(SymbolURI);
388
  if (ScopeProximityMatch) {
389
    // For global symbol, the distance is 0.
390
    Derived.ScopeProximityDistance =
391
        SymbolScope ? ScopeProximityMatch->distance(*SymbolScope) : 0;
392
  }
393
  return Derived;
394
}
395

396
float SymbolRelevanceSignals::evaluateHeuristics() const {
397
  DerivedSignals Derived = calculateDerivedSignals();
398
  float Score = 1;
399

400
  if (Forbidden)
401
    return 0;
402

403
  Score *= NameMatch;
404

405
  // File proximity scores are [0,1] and we translate them into a multiplier in
406
  // the range from 1 to 3.
407
  Score *= 1 + 2 * std::max(fileProximityScore(Derived.FileProximityDistance),
408
                            SemaFileProximityScore);
409

410
  if (ScopeProximityMatch)
411
    // Use a constant scope boost for sema results, as scopes of sema results
412
    // can be tricky (e.g. class/function scope). Set to the max boost as we
413
    // don't load top-level symbols from the preamble and sema results are
414
    // always in the accessible scope.
415
    Score *= SemaSaysInScope
416
                 ? 2.0
417
                 : scopeProximityScore(Derived.ScopeProximityDistance);
418

419
  if (Derived.NameMatchesContext)
420
    Score *= 1.5;
421

422
  // Symbols like local variables may only be referenced within their scope.
423
  // Conversely if we're in that scope, it's likely we'll reference them.
424
  if (Query == CodeComplete) {
425
    // The narrower the scope where a symbol is visible, the more likely it is
426
    // to be relevant when it is available.
427
    switch (Scope) {
428
    case GlobalScope:
429
      break;
430
    case FileScope:
431
      Score *= 1.5f;
432
      break;
433
    case ClassScope:
434
      Score *= 2;
435
      break;
436
    case FunctionScope:
437
      Score *= 4;
438
      break;
439
    }
440
  } else {
441
    // For non-completion queries, the wider the scope where a symbol is
442
    // visible, the more likely it is to be relevant.
443
    switch (Scope) {
444
    case GlobalScope:
445
      break;
446
    case FileScope:
447
      Score *= 0.5f;
448
      break;
449
    default:
450
      // TODO: Handle other scopes as we start to use them for index results.
451
      break;
452
    }
453
  }
454

455
  if (TypeMatchesPreferred)
456
    Score *= 5.0;
457

458
  // Penalize non-instance members when they are accessed via a class instance.
459
  if (!IsInstanceMember &&
460
      (Context == CodeCompletionContext::CCC_DotMemberAccess ||
461
       Context == CodeCompletionContext::CCC_ArrowMemberAccess)) {
462
    Score *= 0.2f;
463
  }
464

465
  if (InBaseClass)
466
    Score *= 0.5f;
467

468
  // Penalize for FixIts.
469
  if (NeedsFixIts)
470
    Score *= 0.5f;
471

472
  // Use a sigmoid style boosting function similar to `References`, which flats
473
  // out nicely for large values. This avoids a sharp gradient for heavily
474
  // referenced symbols. Use smaller gradient for ScopeRefsInFile since ideally
475
  // MainFileRefs <= ScopeRefsInFile.
476
  if (MainFileRefs >= 2) {
477
    // E.g.: (2, 1.12), (9, 2.0), (48, 3.0).
478
    float S = std::pow(MainFileRefs, -0.11);
479
    Score *= 11.0 * (1 - S) / (1 + S) + 0.7;
480
  }
481
  if (ScopeRefsInFile >= 2) {
482
    // E.g.: (2, 1.04), (14, 2.0), (109, 3.0), (400, 3.6).
483
    float S = std::pow(ScopeRefsInFile, -0.10);
484
    Score *= 10.0 * (1 - S) / (1 + S) + 0.7;
485
  }
486

487
  return Score;
488
}
489

490
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
491
                              const SymbolRelevanceSignals &S) {
492
  OS << llvm::formatv("=== Symbol relevance: {0}\n", S.evaluateHeuristics());
493
  OS << llvm::formatv("\tName: {0}\n", S.Name);
494
  OS << llvm::formatv("\tName match: {0}\n", S.NameMatch);
495
  if (S.ContextWords)
496
    OS << llvm::formatv(
497
        "\tMatching context word: {0}\n",
498
        wordMatching(S.Name, S.ContextWords).value_or("<none>"));
499
  OS << llvm::formatv("\tForbidden: {0}\n", S.Forbidden);
500
  OS << llvm::formatv("\tNeedsFixIts: {0}\n", S.NeedsFixIts);
501
  OS << llvm::formatv("\tIsInstanceMember: {0}\n", S.IsInstanceMember);
502
  OS << llvm::formatv("\tInBaseClass: {0}\n", S.InBaseClass);
503
  OS << llvm::formatv("\tContext: {0}\n", getCompletionKindString(S.Context));
504
  OS << llvm::formatv("\tQuery type: {0}\n", static_cast<int>(S.Query));
505
  OS << llvm::formatv("\tScope: {0}\n", static_cast<int>(S.Scope));
506

507
  OS << llvm::formatv("\tSymbol URI: {0}\n", S.SymbolURI);
508
  OS << llvm::formatv("\tSymbol scope: {0}\n",
509
                      S.SymbolScope ? *S.SymbolScope : "<None>");
510

511
  SymbolRelevanceSignals::DerivedSignals Derived = S.calculateDerivedSignals();
512
  if (S.FileProximityMatch) {
513
    unsigned Score = fileProximityScore(Derived.FileProximityDistance);
514
    OS << llvm::formatv("\tIndex URI proximity: {0} (distance={1})\n", Score,
515
                        Derived.FileProximityDistance);
516
  }
517
  OS << llvm::formatv("\tSema file proximity: {0}\n", S.SemaFileProximityScore);
518

519
  OS << llvm::formatv("\tSema says in scope: {0}\n", S.SemaSaysInScope);
520
  if (S.ScopeProximityMatch)
521
    OS << llvm::formatv("\tIndex scope boost: {0}\n",
522
                        scopeProximityScore(Derived.ScopeProximityDistance));
523

524
  OS << llvm::formatv(
525
      "\tType matched preferred: {0} (Context type: {1}, Symbol type: {2}\n",
526
      S.TypeMatchesPreferred, S.HadContextType, S.HadSymbolType);
527

528
  return OS;
529
}
530

531
float evaluateSymbolAndRelevance(float SymbolQuality, float SymbolRelevance) {
532
  return SymbolQuality * SymbolRelevance;
533
}
534

535
// Produces an integer that sorts in the same order as F.
536
// That is: a < b <==> encodeFloat(a) < encodeFloat(b).
537
static uint32_t encodeFloat(float F) {
538
  static_assert(std::numeric_limits<float>::is_iec559);
539
  constexpr uint32_t TopBit = ~(~uint32_t{0} >> 1);
540

541
  // Get the bits of the float. Endianness is the same as for integers.
542
  uint32_t U = llvm::bit_cast<uint32_t>(F);
543
  // IEEE 754 floats compare like sign-magnitude integers.
544
  if (U & TopBit)    // Negative float.
545
    return 0 - U;    // Map onto the low half of integers, order reversed.
546
  return U + TopBit; // Positive floats map onto the high half of integers.
547
}
548

549
std::string sortText(float Score, llvm::StringRef Name) {
550
  // We convert -Score to an integer, and hex-encode for readability.
551
  // Example: [0.5, "foo"] -> "41000000foo"
552
  std::string S;
553
  llvm::raw_string_ostream OS(S);
554
  llvm::write_hex(OS, encodeFloat(-Score), llvm::HexPrintStyle::Lower,
555
                  /*Width=*/2 * sizeof(Score));
556
  OS << Name;
557
  OS.flush();
558
  return S;
559
}
560

561
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
562
                              const SignatureQualitySignals &S) {
563
  OS << llvm::formatv("=== Signature Quality:\n");
564
  OS << llvm::formatv("\tNumber of parameters: {0}\n", S.NumberOfParameters);
565
  OS << llvm::formatv("\tNumber of optional parameters: {0}\n",
566
                      S.NumberOfOptionalParameters);
567
  OS << llvm::formatv("\tKind: {0}\n", S.Kind);
568
  return OS;
569
}
570

571
} // namespace clangd
572
} // namespace clang
573