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) || D->getLinkageInternal() < ExternalLinkage) |
278 | return SymbolRelevanceSignals::FileScope; |
279 | return SymbolRelevanceSignals::GlobalScope; |
280 | } |
281 | |
282 | void SymbolRelevanceSignals::merge(const Symbol &IndexResult) { |
283 | SymbolURI = IndexResult.CanonicalDeclaration.FileURI; |
284 | SymbolScope = IndexResult.Scope; |
285 | IsInstanceMember |= isInstanceMember(IndexResult.SymInfo); |
286 | if (!(IndexResult.Flags & Symbol::VisibleOutsideFile)) { |
287 | Scope = AccessibleScope::FileScope; |
288 | } |
289 | if (MainFileSignals) { |
290 | MainFileRefs = |
291 | std::max(MainFileRefs, |
292 | MainFileSignals->ReferencedSymbols.lookup(IndexResult.ID)); |
293 | ScopeRefsInFile = |
294 | std::max(ScopeRefsInFile, |
295 | MainFileSignals->RelatedNamespaces.lookup(IndexResult.Scope)); |
296 | } |
297 | } |
298 | |
299 | void SymbolRelevanceSignals::computeASTSignals( |
300 | const CodeCompletionResult &SemaResult) { |
301 | if (!MainFileSignals) |
302 | return; |
303 | if ((SemaResult.Kind != CodeCompletionResult::RK_Declaration) && |
304 | (SemaResult.Kind != CodeCompletionResult::RK_Pattern)) |
305 | return; |
306 | if (const NamedDecl *ND = SemaResult.getDeclaration()) { |
307 | if (hasUnstableLinkage(ND)) |
308 | return; |
309 | auto ID = getSymbolID(ND); |
310 | if (!ID) |
311 | return; |
312 | MainFileRefs = |
313 | std::max(MainFileRefs, MainFileSignals->ReferencedSymbols.lookup(ID)); |
314 | if (const auto *NSD = dyn_cast<NamespaceDecl>(ND->getDeclContext())) { |
315 | if (NSD->isAnonymousNamespace()) |
316 | return; |
317 | std::string Scope = printNamespaceScope(*NSD); |
318 | if (!Scope.empty()) |
319 | ScopeRefsInFile = std::max( |
320 | ScopeRefsInFile, MainFileSignals->RelatedNamespaces.lookup(Scope)); |
321 | } |
322 | } |
323 | } |
324 | |
325 | void SymbolRelevanceSignals::merge(const CodeCompletionResult &SemaCCResult) { |
326 | if (SemaCCResult.Availability == CXAvailability_NotAvailable || |
327 | SemaCCResult.Availability == CXAvailability_NotAccessible) |
328 | Forbidden = true; |
329 | |
330 | if (SemaCCResult.Declaration) { |
331 | SemaSaysInScope = true; |
332 | // We boost things that have decls in the main file. We give a fixed score |
333 | // for all other declarations in sema as they are already included in the |
334 | // translation unit. |
335 | float DeclProximity = (hasDeclInMainFile(*SemaCCResult.Declaration) || |
336 | hasUsingDeclInMainFile(SemaCCResult)) |
337 | ? 1.0 |
338 | : 0.6; |
339 | SemaFileProximityScore = std::max(DeclProximity, SemaFileProximityScore); |
340 | IsInstanceMember |= isInstanceMember(SemaCCResult.Declaration); |
341 | InBaseClass |= SemaCCResult.InBaseClass; |
342 | } |
343 | |
344 | computeASTSignals(SemaCCResult); |
345 | // Declarations are scoped, others (like macros) are assumed global. |
346 | if (SemaCCResult.Declaration) |
347 | Scope = std::min(Scope, computeScope(SemaCCResult.Declaration)); |
348 | |
349 | NeedsFixIts = !SemaCCResult.FixIts.empty(); |
350 | } |
351 | |
352 | static float fileProximityScore(unsigned FileDistance) { |
353 | // Range: [0, 1] |
354 | // FileDistance = [0, 1, 2, 3, 4, .., FileDistance::Unreachable] |
355 | // Score = [1, 0.82, 0.67, 0.55, 0.45, .., 0] |
356 | if (FileDistance == FileDistance::Unreachable) |
357 | return 0; |
358 | // Assume approximately default options are used for sensible scoring. |
359 | return std::exp(FileDistance * -0.4f / FileDistanceOptions().UpCost); |
360 | } |
361 | |
362 | static float scopeProximityScore(unsigned ScopeDistance) { |
363 | // Range: [0.6, 2]. |
364 | // ScopeDistance = [0, 1, 2, 3, 4, 5, 6, 7, .., FileDistance::Unreachable] |
365 | // Score = [2.0, 1.55, 1.2, 0.93, 0.72, 0.65, 0.65, 0.65, .., 0.6] |
366 | if (ScopeDistance == FileDistance::Unreachable) |
367 | return 0.6f; |
368 | return std::max(0.65, 2.0 * std::pow(0.6, ScopeDistance / 2.0)); |
369 | } |
370 | |
371 | static std::optional<llvm::StringRef> |
372 | wordMatching(llvm::StringRef Name, const llvm::StringSet<> *ContextWords) { |
373 | if (ContextWords) |
374 | for (const auto &Word : ContextWords->keys()) |
375 | if (Name.contains_insensitive(Word)) |
376 | return Word; |
377 | return std::nullopt; |
378 | } |
379 | |
380 | SymbolRelevanceSignals::DerivedSignals |
381 | SymbolRelevanceSignals::calculateDerivedSignals() const { |
382 | DerivedSignals Derived; |
383 | Derived.NameMatchesContext = wordMatching(Name, ContextWords).has_value(); |
384 | Derived.FileProximityDistance = !FileProximityMatch || SymbolURI.empty() |
385 | ? FileDistance::Unreachable |
386 | : FileProximityMatch->distance(SymbolURI); |
387 | if (ScopeProximityMatch) { |
388 | // For global symbol, the distance is 0. |
389 | Derived.ScopeProximityDistance = |
390 | SymbolScope ? ScopeProximityMatch->distance(*SymbolScope) : 0; |
391 | } |
392 | return Derived; |
393 | } |
394 | |
395 | float SymbolRelevanceSignals::evaluateHeuristics() const { |
396 | DerivedSignals Derived = calculateDerivedSignals(); |
397 | float Score = 1; |
398 | |
399 | if (Forbidden) |
400 | return 0; |
401 | |
402 | Score *= NameMatch; |
403 | |
404 | // File proximity scores are [0,1] and we translate them into a multiplier in |
405 | // the range from 1 to 3. |
406 | Score *= 1 + 2 * std::max(fileProximityScore(Derived.FileProximityDistance), |
407 | SemaFileProximityScore); |
408 | |
409 | if (ScopeProximityMatch) |
410 | // Use a constant scope boost for sema results, as scopes of sema results |
411 | // can be tricky (e.g. class/function scope). Set to the max boost as we |
412 | // don't load top-level symbols from the preamble and sema results are |
413 | // always in the accessible scope. |
414 | Score *= SemaSaysInScope |
415 | ? 2.0 |
416 | : scopeProximityScore(Derived.ScopeProximityDistance); |
417 | |
418 | if (Derived.NameMatchesContext) |
419 | Score *= 1.5; |
420 | |
421 | // Symbols like local variables may only be referenced within their scope. |
422 | // Conversely if we're in that scope, it's likely we'll reference them. |
423 | if (Query == CodeComplete) { |
424 | // The narrower the scope where a symbol is visible, the more likely it is |
425 | // to be relevant when it is available. |
426 | switch (Scope) { |
427 | case GlobalScope: |
428 | break; |
429 | case FileScope: |
430 | Score *= 1.5f; |
431 | break; |
432 | case ClassScope: |
433 | Score *= 2; |
434 | break; |
435 | case FunctionScope: |
436 | Score *= 4; |
437 | break; |
438 | } |
439 | } else { |
440 | // For non-completion queries, the wider the scope where a symbol is |
441 | // visible, the more likely it is to be relevant. |
442 | switch (Scope) { |
443 | case GlobalScope: |
444 | break; |
445 | case FileScope: |
446 | Score *= 0.5f; |
447 | break; |
448 | default: |
449 | // TODO: Handle other scopes as we start to use them for index results. |
450 | break; |
451 | } |
452 | } |
453 | |
454 | if (TypeMatchesPreferred) |
455 | Score *= 5.0; |
456 | |
457 | // Penalize non-instance members when they are accessed via a class instance. |
458 | if (!IsInstanceMember && |
459 | (Context == CodeCompletionContext::CCC_DotMemberAccess || |
460 | Context == CodeCompletionContext::CCC_ArrowMemberAccess)) { |
461 | Score *= 0.2f; |
462 | } |
463 | |
464 | if (InBaseClass) |
465 | Score *= 0.5f; |
466 | |
467 | // Penalize for FixIts. |
468 | if (NeedsFixIts) |
469 | Score *= 0.5f; |
470 | |
471 | // Use a sigmoid style boosting function similar to `References`, which flats |
472 | // out nicely for large values. This avoids a sharp gradient for heavily |
473 | // referenced symbols. Use smaller gradient for ScopeRefsInFile since ideally |
474 | // MainFileRefs <= ScopeRefsInFile. |
475 | if (MainFileRefs >= 2) { |
476 | // E.g.: (2, 1.12), (9, 2.0), (48, 3.0). |
477 | float S = std::pow(MainFileRefs, -0.11); |
478 | Score *= 11.0 * (1 - S) / (1 + S) + 0.7; |
479 | } |
480 | if (ScopeRefsInFile >= 2) { |
481 | // E.g.: (2, 1.04), (14, 2.0), (109, 3.0), (400, 3.6). |
482 | float S = std::pow(ScopeRefsInFile, -0.10); |
483 | Score *= 10.0 * (1 - S) / (1 + S) + 0.7; |
484 | } |
485 | |
486 | return Score; |
487 | } |
488 | |
489 | llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, |
490 | const SymbolRelevanceSignals &S) { |
491 | OS << llvm::formatv("=== Symbol relevance: {0}\n" , S.evaluateHeuristics()); |
492 | OS << llvm::formatv("\tName: {0}\n" , S.Name); |
493 | OS << llvm::formatv("\tName match: {0}\n" , S.NameMatch); |
494 | if (S.ContextWords) |
495 | OS << llvm::formatv( |
496 | "\tMatching context word: {0}\n" , |
497 | wordMatching(S.Name, S.ContextWords).value_or("<none>" )); |
498 | OS << llvm::formatv("\tForbidden: {0}\n" , S.Forbidden); |
499 | OS << llvm::formatv("\tNeedsFixIts: {0}\n" , S.NeedsFixIts); |
500 | OS << llvm::formatv("\tIsInstanceMember: {0}\n" , S.IsInstanceMember); |
501 | OS << llvm::formatv("\tInBaseClass: {0}\n" , S.InBaseClass); |
502 | OS << llvm::formatv("\tContext: {0}\n" , getCompletionKindString(S.Context)); |
503 | OS << llvm::formatv("\tQuery type: {0}\n" , static_cast<int>(S.Query)); |
504 | OS << llvm::formatv("\tScope: {0}\n" , static_cast<int>(S.Scope)); |
505 | |
506 | OS << llvm::formatv("\tSymbol URI: {0}\n" , S.SymbolURI); |
507 | OS << llvm::formatv("\tSymbol scope: {0}\n" , |
508 | S.SymbolScope ? *S.SymbolScope : "<None>" ); |
509 | |
510 | SymbolRelevanceSignals::DerivedSignals Derived = S.calculateDerivedSignals(); |
511 | if (S.FileProximityMatch) { |
512 | unsigned Score = fileProximityScore(Derived.FileProximityDistance); |
513 | OS << llvm::formatv("\tIndex URI proximity: {0} (distance={1})\n" , Score, |
514 | Derived.FileProximityDistance); |
515 | } |
516 | OS << llvm::formatv("\tSema file proximity: {0}\n" , S.SemaFileProximityScore); |
517 | |
518 | OS << llvm::formatv("\tSema says in scope: {0}\n" , S.SemaSaysInScope); |
519 | if (S.ScopeProximityMatch) |
520 | OS << llvm::formatv("\tIndex scope boost: {0}\n" , |
521 | scopeProximityScore(Derived.ScopeProximityDistance)); |
522 | |
523 | OS << llvm::formatv( |
524 | "\tType matched preferred: {0} (Context type: {1}, Symbol type: {2}\n" , |
525 | S.TypeMatchesPreferred, S.HadContextType, S.HadSymbolType); |
526 | |
527 | return OS; |
528 | } |
529 | |
530 | float evaluateSymbolAndRelevance(float SymbolQuality, float SymbolRelevance) { |
531 | return SymbolQuality * SymbolRelevance; |
532 | } |
533 | |
534 | // Produces an integer that sorts in the same order as F. |
535 | // That is: a < b <==> encodeFloat(a) < encodeFloat(b). |
536 | static uint32_t encodeFloat(float F) { |
537 | static_assert(std::numeric_limits<float>::is_iec559); |
538 | constexpr uint32_t TopBit = ~(~uint32_t{0} >> 1); |
539 | |
540 | // Get the bits of the float. Endianness is the same as for integers. |
541 | uint32_t U = llvm::bit_cast<uint32_t>(F); |
542 | // IEEE 754 floats compare like sign-magnitude integers. |
543 | if (U & TopBit) // Negative float. |
544 | return 0 - U; // Map onto the low half of integers, order reversed. |
545 | return U + TopBit; // Positive floats map onto the high half of integers. |
546 | } |
547 | |
548 | std::string sortText(float Score, llvm::StringRef Name) { |
549 | // We convert -Score to an integer, and hex-encode for readability. |
550 | // Example: [0.5, "foo"] -> "41000000foo" |
551 | std::string S; |
552 | llvm::raw_string_ostream OS(S); |
553 | llvm::write_hex(OS, encodeFloat(-Score), llvm::HexPrintStyle::Lower, |
554 | /*Width=*/2 * sizeof(Score)); |
555 | OS << Name; |
556 | OS.flush(); |
557 | return S; |
558 | } |
559 | |
560 | llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, |
561 | const SignatureQualitySignals &S) { |
562 | OS << llvm::formatv("=== Signature Quality:\n" ); |
563 | OS << llvm::formatv("\tNumber of parameters: {0}\n" , S.NumberOfParameters); |
564 | OS << llvm::formatv("\tNumber of optional parameters: {0}\n" , |
565 | S.NumberOfOptionalParameters); |
566 | OS << llvm::formatv("\tKind: {0}\n" , S.Kind); |
567 | return OS; |
568 | } |
569 | |
570 | } // namespace clangd |
571 | } // namespace clang |
572 | |