clang-tools 20.0.0git
Quality.cpp
Go to the documentation of this file.
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
31namespace clang {
32namespace clangd {
33
34static 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
43static 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
54 if (const auto *FD = dyn_cast<FunctionDecl>(&ND)) {
55 if (FD->isOverloadedOperator())
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);
77#undef MAP
78 };
79 return Switch().Visit(&ND);
80}
81
83categorize(const CodeCompletionResult &R) {
84 if (R.Declaration)
85 return categorize(*R.Declaration);
86 if (R.Kind == CodeCompletionResult::RK_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:
93 case CXCursor_ModuleImportDecl:
95 case CXCursor_MacroDefinition:
97 case CXCursor_TypeRef:
99 case CXCursor_MemberRef:
101 case CXCursor_Constructor:
103 default:
105 }
106}
107
109categorize(const index::SymbolInfo &D) {
110 switch (D.Kind) {
111 case index::SymbolKind::Namespace:
112 case index::SymbolKind::NamespaceAlias:
114 case index::SymbolKind::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:
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:
136 case index::SymbolKind::Destructor:
138 case index::SymbolKind::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:
146 case index::SymbolKind::Using:
147 case index::SymbolKind::Module:
148 case index::SymbolKind::Unknown:
150 }
151 llvm_unreachable("Unknown index::SymbolKind");
152}
153
154static 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
164static 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
175void 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())
183 } else if (SemaCCResult.Kind == CodeCompletionResult::RK_Macro)
185 ReservedName || isReservedName(SemaCCResult.Macro->getName());
186}
187
191 References = std::max(IndexResult.References, References);
194}
195
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;
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
246llvm::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
258computeScope(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())
271 InClass = InClass || DC->isRecord();
272 }
273 if (InClass)
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))
281}
282
284 SymbolURI = IndexResult.CanonicalDeclaration.FileURI;
285 SymbolScope = IndexResult.Scope;
289 }
290 if (MainFileSignals) {
292 std::max(MainFileRefs,
295 std::max(ScopeRefsInFile,
297 }
298}
299
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;
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(
322 }
323 }
324}
325
326void 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
353static 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]
358 return 0;
359 // Assume approximately default options are used for sensible scoring.
360 return std::exp(FileDistance * -0.4f / FileDistanceOptions().UpCost);
361}
362
363static 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]
368 return 0.6f;
369 return std::max(0.65, 2.0 * std::pow(0.6, ScopeDistance / 2.0));
370}
371
372static std::optional<llvm::StringRef>
373wordMatching(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
381SymbolRelevanceSignals::DerivedSignals
383 DerivedSignals Derived;
384 Derived.NameMatchesContext = wordMatching(Name, ContextWords).has_value();
389 // For global symbol, the distance is 0.
390 Derived.ScopeProximityDistance =
392 }
393 return Derived;
394}
395
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),
409
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.
416 ? 2.0
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
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
490llvm::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) {
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",
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
531float 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).
537static 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
549std::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
561llvm::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
CaptureMode CM
const FunctionDecl * Decl
llvm::SmallString< 256U > Name
const Symbol * IndexResult
const CodeCompletionResult * SemaResult
std::string Word
std::optional< float > Score
NodeType Type
#define MAP(DeclType, Category)
llvm::raw_string_ostream OS
Definition: TraceTests.cpp:160
A context is an immutable container for per-request data that must be propagated through layers that ...
Definition: Context.h:69
static constexpr unsigned Unreachable
Definition: FileDistance.h:69
Support lookups like FileDistance, but the lookup keys are symbol scopes.
Definition: FileDistance.h:112
unsigned distance(llvm::StringRef SymbolScope)
unsigned distance(llvm::StringRef URI)
static bool hasUsingDeclInMainFile(const CodeCompletionResult &R)
Definition: Quality.cpp:43
SymbolID getSymbolID(const Decl *D)
Gets the symbol ID for a declaration. Returned SymbolID might be null.
Definition: AST.cpp:331
static float fileProximityScore(unsigned FileDistance)
Definition: Quality.cpp:353
static bool isInstanceMember(const NamedDecl *ND)
Definition: Quality.cpp:154
std::string sortText(float Score, llvm::StringRef Name)
Returns a string that sorts in the same order as (-Score, Tiebreak), for LSP.
Definition: Quality.cpp:549
static std::optional< llvm::StringRef > wordMatching(llvm::StringRef Name, const llvm::StringSet<> *ContextWords)
Definition: Quality.cpp:373
bool isReservedName(llvm::StringRef Name)
Returns true if Name is reserved, like _Foo or __Vector_base.
Definition: SourceCode.h:334
static float scopeProximityScore(unsigned ScopeDistance)
Definition: Quality.cpp:363
bool isInsideMainFile(SourceLocation Loc, const SourceManager &SM)
Returns true iff Loc is inside the main file.
Definition: SourceCode.cpp:423
llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, const CodeCompletion &C)
static SymbolRelevanceSignals::AccessibleScope computeScope(const NamedDecl *D)
Definition: Quality.cpp:258
static SymbolQualitySignals::SymbolCategory categorize(const NamedDecl &ND)
Definition: Quality.cpp:53
bool hasUnstableLinkage(const Decl *D)
Whether we must avoid computing linkage for D during code completion.
Definition: AST.cpp:699
static uint32_t encodeFloat(float F)
Definition: Quality.cpp:537
static bool hasDeclInMainFile(const Decl &D)
Definition: Quality.cpp:34
bool isImplementationDetail(const Decl *D)
Returns true if the declaration is considered implementation detail based on heuristics.
Definition: AST.cpp:162
float evaluateSymbolAndRelevance(float SymbolQuality, float SymbolRelevance)
Combine symbol quality and relevance into a single score.
Definition: Quality.cpp:531
std::string printNamespaceScope(const DeclContext &DC)
Returns the first enclosing namespace scope starting from DC.
Definition: AST.cpp:277
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
llvm::DenseMap< SymbolID, unsigned > ReferencedSymbols
Number of occurrences of each symbol present in the file.
Definition: ASTSignals.h:29
llvm::StringMap< unsigned > RelatedNamespaces
Namespaces whose symbols are used in the file, and the number of such distinct symbols.
Definition: ASTSignals.h:32
Attributes of a symbol that affect how much we like it.
Definition: Quality.h:56
enum clang::clangd::SymbolQualitySignals::SymbolCategory Category
void merge(const CodeCompletionResult &SemaCCResult)
Definition: Quality.cpp:175
Set of derived signals computed by calculateDerivedSignals().
Definition: Quality.h:152
bool NameMatchesContext
Whether Name contains some word from context.
Definition: Quality.h:154
unsigned FileProximityDistance
Min distance between SymbolURI and all the headers included by the TU.
Definition: Quality.h:156
unsigned ScopeProximityDistance
Min distance between SymbolScope and all the available scopes.
Definition: Quality.h:158
Attributes of a symbol-query pair that affect how much we like it.
Definition: Quality.h:86
float NameMatch
0-1+ fuzzy-match score for unqualified name. Must be explicitly assigned.
Definition: Quality.h:90
bool NeedsFixIts
Whether fixits needs to be applied for that completion or not.
Definition: Quality.h:95
DerivedSignals calculateDerivedSignals() const
Definition: Quality.cpp:382
unsigned MainFileRefs
Number of references to the candidate in the main file.
Definition: Quality.h:144
llvm::StringRef Name
The name of the symbol (for ContextWords). Must be explicitly assigned.
Definition: Quality.h:88
void computeASTSignals(const CodeCompletionResult &SemaResult)
Definition: Quality.cpp:300
llvm::StringRef SymbolURI
These are used to calculate proximity between the index symbol and the query.
Definition: Quality.h:101
unsigned ScopeRefsInFile
Number of unique symbols in the main file which belongs to candidate's namespace.
Definition: Quality.h:148
const ASTSignals * MainFileSignals
Definition: Quality.h:142
llvm::StringSet * ContextWords
Lowercase words relevant to the context (e.g. near the completion point).
Definition: Quality.h:92
void merge(const CodeCompletionResult &SemaResult)
Definition: Quality.cpp:326
float SemaFileProximityScore
FIXME: unify with index proximity score - signals should be source-independent.
Definition: Quality.h:105
enum clang::clangd::SymbolRelevanceSignals::QueryType Query
enum clang::clangd::SymbolRelevanceSignals::AccessibleScope Scope
std::optional< llvm::StringRef > SymbolScope
Definition: Quality.h:109
The class presents a C++ symbol, e.g.
Definition: Symbol.h:39
@ Deprecated
Indicates if the symbol is deprecated.
Definition: Symbol.h:143
@ ImplementationDetail
Symbol is an implementation detail.
Definition: Symbol.h:145
@ VisibleOutsideFile
Symbol is visible to other files (not e.g. a static helper function).
Definition: Symbol.h:147