1 | //===--- InlayHints.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 | #include "InlayHints.h" |
9 | #include "../clang-tidy/utils/DesignatedInitializers.h" |
10 | #include "AST.h" |
11 | #include "Config.h" |
12 | #include "ParsedAST.h" |
13 | #include "Protocol.h" |
14 | #include "SourceCode.h" |
15 | #include "clang/AST/ASTDiagnostic.h" |
16 | #include "clang/AST/Decl.h" |
17 | #include "clang/AST/DeclBase.h" |
18 | #include "clang/AST/DeclarationName.h" |
19 | #include "clang/AST/Expr.h" |
20 | #include "clang/AST/ExprCXX.h" |
21 | #include "clang/AST/RecursiveASTVisitor.h" |
22 | #include "clang/AST/Stmt.h" |
23 | #include "clang/AST/StmtVisitor.h" |
24 | #include "clang/AST/Type.h" |
25 | #include "clang/Basic/Builtins.h" |
26 | #include "clang/Basic/OperatorKinds.h" |
27 | #include "clang/Basic/SourceLocation.h" |
28 | #include "clang/Basic/SourceManager.h" |
29 | #include "clang/Sema/HeuristicResolver.h" |
30 | #include "llvm/ADT/DenseSet.h" |
31 | #include "llvm/ADT/STLExtras.h" |
32 | #include "llvm/ADT/SmallVector.h" |
33 | #include "llvm/ADT/StringExtras.h" |
34 | #include "llvm/ADT/StringRef.h" |
35 | #include "llvm/ADT/Twine.h" |
36 | #include "llvm/ADT/identity.h" |
37 | #include "llvm/Support/Casting.h" |
38 | #include "llvm/Support/ErrorHandling.h" |
39 | #include "llvm/Support/FormatVariadic.h" |
40 | #include "llvm/Support/SaveAndRestore.h" |
41 | #include "llvm/Support/ScopedPrinter.h" |
42 | #include "llvm/Support/raw_ostream.h" |
43 | #include <algorithm> |
44 | #include <iterator> |
45 | #include <optional> |
46 | #include <string> |
47 | |
48 | namespace clang { |
49 | namespace clangd { |
50 | namespace { |
51 | |
52 | // For now, inlay hints are always anchored at the left or right of their range. |
53 | enum class HintSide { Left, Right }; |
54 | |
55 | void stripLeadingUnderscores(StringRef &Name) { Name = Name.ltrim(Char: '_'); } |
56 | |
57 | // getDeclForType() returns the decl responsible for Type's spelling. |
58 | // This is the inverse of ASTContext::getTypeDeclType(). |
59 | template <typename Ty, typename = decltype(((Ty *)nullptr)->getDecl())> |
60 | const NamedDecl *getDeclForTypeImpl(const Ty *T) { |
61 | return T->getDecl(); |
62 | } |
63 | const NamedDecl *getDeclForTypeImpl(const void *T) { return nullptr; } |
64 | const NamedDecl *getDeclForType(const Type *T) { |
65 | switch (T->getTypeClass()) { |
66 | #define ABSTRACT_TYPE(TY, BASE) |
67 | #define TYPE(TY, BASE) \ |
68 | case Type::TY: \ |
69 | return getDeclForTypeImpl(llvm::cast<TY##Type>(T)); |
70 | #include "clang/AST/TypeNodes.inc" |
71 | } |
72 | llvm_unreachable("Unknown TypeClass enum"); |
73 | } |
74 | |
75 | // getSimpleName() returns the plain identifier for an entity, if any. |
76 | llvm::StringRef getSimpleName(const DeclarationName &DN) { |
77 | if (IdentifierInfo *Ident = DN.getAsIdentifierInfo()) |
78 | return Ident->getName(); |
79 | return ""; |
80 | } |
81 | llvm::StringRef getSimpleName(const NamedDecl &D) { |
82 | return getSimpleName(DN: D.getDeclName()); |
83 | } |
84 | llvm::StringRef getSimpleName(QualType T) { |
85 | if (const auto *ET = llvm::dyn_cast<ElaboratedType>(T)) |
86 | return getSimpleName(ET->getNamedType()); |
87 | if (const auto *BT = llvm::dyn_cast<BuiltinType>(T)) { |
88 | PrintingPolicy PP(LangOptions{}); |
89 | PP.adjustForCPlusPlus(); |
90 | return BT->getName(PP); |
91 | } |
92 | if (const auto *D = getDeclForType(T: T.getTypePtr())) |
93 | return getSimpleName(DN: D->getDeclName()); |
94 | return ""; |
95 | } |
96 | |
97 | // Returns a very abbreviated form of an expression, or "" if it's too complex. |
98 | // For example: `foo->bar()` would produce "bar". |
99 | // This is used to summarize e.g. the condition of a while loop. |
100 | std::string summarizeExpr(const Expr *E) { |
101 | struct Namer : ConstStmtVisitor<Namer, std::string> { |
102 | std::string Visit(const Expr *E) { |
103 | if (E == nullptr) |
104 | return ""; |
105 | return ConstStmtVisitor::Visit(E->IgnoreImplicit()); |
106 | } |
107 | |
108 | // Any sort of decl reference, we just use the unqualified name. |
109 | std::string VisitMemberExpr(const MemberExpr *E) { |
110 | return getSimpleName(*E->getMemberDecl()).str(); |
111 | } |
112 | std::string VisitDeclRefExpr(const DeclRefExpr *E) { |
113 | return getSimpleName(D: *E->getFoundDecl()).str(); |
114 | } |
115 | std::string VisitCallExpr(const CallExpr *E) { |
116 | std::string Result = Visit(E: E->getCallee()); |
117 | Result += E->getNumArgs() == 0 ? "()": "(...)"; |
118 | return Result; |
119 | } |
120 | std::string |
121 | VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E) { |
122 | return getSimpleName(DN: E->getMember()).str(); |
123 | } |
124 | std::string |
125 | VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *E) { |
126 | return getSimpleName(DN: E->getDeclName()).str(); |
127 | } |
128 | std::string VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *E) { |
129 | return getSimpleName(E->getType()).str(); |
130 | } |
131 | std::string VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E) { |
132 | return getSimpleName(E->getType()).str(); |
133 | } |
134 | |
135 | // Step through implicit nodes that clang doesn't classify as such. |
136 | std::string VisitCXXMemberCallExpr(const CXXMemberCallExpr *E) { |
137 | // Call to operator bool() inside if (X): dispatch to X. |
138 | if (E->getNumArgs() == 0 && E->getMethodDecl() && |
139 | E->getMethodDecl()->getDeclName().getNameKind() == |
140 | DeclarationName::CXXConversionFunctionName && |
141 | E->getSourceRange() == |
142 | E->getImplicitObjectArgument()->getSourceRange()) |
143 | return Visit(E: E->getImplicitObjectArgument()); |
144 | return ConstStmtVisitor::VisitCXXMemberCallExpr(E); |
145 | } |
146 | std::string VisitCXXConstructExpr(const CXXConstructExpr *E) { |
147 | if (E->getNumArgs() == 1) |
148 | return Visit(E: E->getArg(Arg: 0)); |
149 | return ""; |
150 | } |
151 | |
152 | // Literals are just printed |
153 | std::string VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { |
154 | return "nullptr"; |
155 | } |
156 | std::string VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { |
157 | return E->getValue() ? "true": "false"; |
158 | } |
159 | std::string VisitIntegerLiteral(const IntegerLiteral *E) { |
160 | return llvm::to_string(E->getValue()); |
161 | } |
162 | std::string VisitFloatingLiteral(const FloatingLiteral *E) { |
163 | std::string Result; |
164 | llvm::raw_string_ostream OS(Result); |
165 | E->getValue().print(OS); |
166 | // Printer adds newlines?! |
167 | Result.resize(n: llvm::StringRef(Result).rtrim().size()); |
168 | return Result; |
169 | } |
170 | std::string VisitStringLiteral(const StringLiteral *E) { |
171 | std::string Result = "\""; |
172 | if (E->containsNonAscii()) { |
173 | Result += "..."; |
174 | } else { |
175 | llvm::raw_string_ostream OS(Result); |
176 | if (E->getLength() > 10) { |
177 | llvm::printEscapedString(Name: E->getString().take_front(N: 7), Out&: OS); |
178 | Result += "..."; |
179 | } else { |
180 | llvm::printEscapedString(Name: E->getString(), Out&: OS); |
181 | } |
182 | } |
183 | Result.push_back(c: '"'); |
184 | return Result; |
185 | } |
186 | |
187 | // Simple operators. Motivating cases are `!x` and `I < Length`. |
188 | std::string printUnary(llvm::StringRef Spelling, const Expr *Operand, |
189 | bool Prefix) { |
190 | std::string Sub = Visit(E: Operand); |
191 | if (Sub.empty()) |
192 | return ""; |
193 | if (Prefix) |
194 | return (Spelling + Sub).str(); |
195 | Sub += Spelling; |
196 | return Sub; |
197 | } |
198 | bool InsideBinary = false; // No recursing into binary expressions. |
199 | std::string printBinary(llvm::StringRef Spelling, const Expr *LHSOp, |
200 | const Expr *RHSOp) { |
201 | if (InsideBinary) |
202 | return ""; |
203 | llvm::SaveAndRestore InBinary(InsideBinary, true); |
204 | |
205 | std::string LHS = Visit(E: LHSOp); |
206 | std::string RHS = Visit(E: RHSOp); |
207 | if (LHS.empty() && RHS.empty()) |
208 | return ""; |
209 | |
210 | if (LHS.empty()) |
211 | LHS = "..."; |
212 | LHS.push_back(c: ' '); |
213 | LHS += Spelling; |
214 | LHS.push_back(c: ' '); |
215 | if (RHS.empty()) |
216 | LHS += "..."; |
217 | else |
218 | LHS += RHS; |
219 | return LHS; |
220 | } |
221 | std::string VisitUnaryOperator(const UnaryOperator *E) { |
222 | return printUnary(Spelling: E->getOpcodeStr(Op: E->getOpcode()), Operand: E->getSubExpr(), |
223 | Prefix: !E->isPostfix()); |
224 | } |
225 | std::string VisitBinaryOperator(const BinaryOperator *E) { |
226 | return printBinary(Spelling: E->getOpcodeStr(Op: E->getOpcode()), LHSOp: E->getLHS(), |
227 | RHSOp: E->getRHS()); |
228 | } |
229 | std::string VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *E) { |
230 | const char *Spelling = getOperatorSpelling(Operator: E->getOperator()); |
231 | // Handle weird unary-that-look-like-binary postfix operators. |
232 | if ((E->getOperator() == OO_PlusPlus || |
233 | E->getOperator() == OO_MinusMinus) && |
234 | E->getNumArgs() == 2) |
235 | return printUnary(Spelling, Operand: E->getArg(0), Prefix: false); |
236 | if (E->isInfixBinaryOp()) |
237 | return printBinary(Spelling, LHSOp: E->getArg(0), RHSOp: E->getArg(1)); |
238 | if (E->getNumArgs() == 1) { |
239 | switch (E->getOperator()) { |
240 | case OO_Plus: |
241 | case OO_Minus: |
242 | case OO_Star: |
243 | case OO_Amp: |
244 | case OO_Tilde: |
245 | case OO_Exclaim: |
246 | case OO_PlusPlus: |
247 | case OO_MinusMinus: |
248 | return printUnary(Spelling, Operand: E->getArg(0), Prefix: true); |
249 | default: |
250 | break; |
251 | } |
252 | } |
253 | return ""; |
254 | } |
255 | }; |
256 | return Namer{}.Visit(E); |
257 | } |
258 | |
259 | // Determines if any intermediate type in desugaring QualType QT is of |
260 | // substituted template parameter type. Ignore pointer or reference wrappers. |
261 | bool isSugaredTemplateParameter(QualType QT) { |
262 | static auto PeelWrapper = [](QualType QT) { |
263 | // Neither `PointerType` nor `ReferenceType` is considered as sugared |
264 | // type. Peel it. |
265 | QualType Peeled = QT->getPointeeType(); |
266 | return Peeled.isNull() ? QT : Peeled; |
267 | }; |
268 | |
269 | // This is a bit tricky: we traverse the type structure and find whether or |
270 | // not a type in the desugaring process is of SubstTemplateTypeParmType. |
271 | // During the process, we may encounter pointer or reference types that are |
272 | // not marked as sugared; therefore, the desugar function won't apply. To |
273 | // move forward the traversal, we retrieve the pointees using |
274 | // QualType::getPointeeType(). |
275 | // |
276 | // However, getPointeeType could leap over our interests: The QT::getAs<T>() |
277 | // invoked would implicitly desugar the type. Consequently, if the |
278 | // SubstTemplateTypeParmType is encompassed within a TypedefType, we may lose |
279 | // the chance to visit it. |
280 | // For example, given a QT that represents `std::vector<int *>::value_type`: |
281 | // `-ElaboratedType 'value_type' sugar |
282 | // `-TypedefType 'vector<int *>::value_type' sugar |
283 | // |-Typedef 'value_type' |
284 | // `-SubstTemplateTypeParmType 'int *' sugar class depth 0 index 0 T |
285 | // |-ClassTemplateSpecialization 'vector' |
286 | // `-PointerType 'int *' |
287 | // `-BuiltinType 'int' |
288 | // Applying `getPointeeType` to QT results in 'int', a child of our target |
289 | // node SubstTemplateTypeParmType. |
290 | // |
291 | // As such, we always prefer the desugared over the pointee for next type |
292 | // in the iteration. It could avoid the getPointeeType's implicit desugaring. |
293 | while (true) { |
294 | if (QT->getAs<SubstTemplateTypeParmType>()) |
295 | return true; |
296 | QualType Desugared = QT->getLocallyUnqualifiedSingleStepDesugaredType(); |
297 | if (Desugared != QT) |
298 | QT = Desugared; |
299 | else if (auto Peeled = PeelWrapper(Desugared); Peeled != QT) |
300 | QT = Peeled; |
301 | else |
302 | break; |
303 | } |
304 | return false; |
305 | } |
306 | |
307 | // A simple wrapper for `clang::desugarForDiagnostic` that provides optional |
308 | // semantic. |
309 | std::optional<QualType> desugar(ASTContext &AST, QualType QT) { |
310 | bool ShouldAKA = false; |
311 | auto Desugared = clang::desugarForDiagnostic(Context&: AST, QT, ShouldAKA); |
312 | if (!ShouldAKA) |
313 | return std::nullopt; |
314 | return Desugared; |
315 | } |
316 | |
317 | // Apply a series of heuristic methods to determine whether or not a QualType QT |
318 | // is suitable for desugaring (e.g. getting the real name behind the using-alias |
319 | // name). If so, return the desugared type. Otherwise, return the unchanged |
320 | // parameter QT. |
321 | // |
322 | // This could be refined further. See |
323 | // https://github.com/clangd/clangd/issues/1298. |
324 | QualType maybeDesugar(ASTContext &AST, QualType QT) { |
325 | // Prefer desugared type for name that aliases the template parameters. |
326 | // This can prevent things like printing opaque `: type` when accessing std |
327 | // containers. |
328 | if (isSugaredTemplateParameter(QT)) |
329 | return desugar(AST, QT).value_or(QT); |
330 | |
331 | // Prefer desugared type for `decltype(expr)` specifiers. |
332 | if (QT->isDecltypeType()) |
333 | return QT.getCanonicalType(); |
334 | if (const AutoType *AT = QT->getContainedAutoType()) |
335 | if (!AT->getDeducedType().isNull() && |
336 | AT->getDeducedType()->isDecltypeType()) |
337 | return QT.getCanonicalType(); |
338 | |
339 | return QT; |
340 | } |
341 | |
342 | // Given a callee expression `Fn`, if the call is through a function pointer, |
343 | // try to find the declaration of the corresponding function pointer type, |
344 | // so that we can recover argument names from it. |
345 | // FIXME: This function is mostly duplicated in SemaCodeComplete.cpp; unify. |
346 | static FunctionProtoTypeLoc getPrototypeLoc(Expr *Fn) { |
347 | TypeLoc Target; |
348 | Expr *NakedFn = Fn->IgnoreParenCasts(); |
349 | if (const auto *T = NakedFn->getType().getTypePtr()->getAs<TypedefType>()) { |
350 | Target = T->getDecl()->getTypeSourceInfo()->getTypeLoc(); |
351 | } else if (const auto *DR = dyn_cast<DeclRefExpr>(NakedFn)) { |
352 | const auto *D = DR->getDecl(); |
353 | if (const auto *const VD = dyn_cast<VarDecl>(D)) { |
354 | Target = VD->getTypeSourceInfo()->getTypeLoc(); |
355 | } |
356 | } |
357 | |
358 | if (!Target) |
359 | return {}; |
360 | |
361 | // Unwrap types that may be wrapping the function type |
362 | while (true) { |
363 | if (auto P = Target.getAs<PointerTypeLoc>()) { |
364 | Target = P.getPointeeLoc(); |
365 | continue; |
366 | } |
367 | if (auto A = Target.getAs<AttributedTypeLoc>()) { |
368 | Target = A.getModifiedLoc(); |
369 | continue; |
370 | } |
371 | if (auto P = Target.getAs<ParenTypeLoc>()) { |
372 | Target = P.getInnerLoc(); |
373 | continue; |
374 | } |
375 | break; |
376 | } |
377 | |
378 | if (auto F = Target.getAs<FunctionProtoTypeLoc>()) { |
379 | // In some edge cases the AST can contain a "trivial" FunctionProtoTypeLoc |
380 | // which has null parameters. Avoid these as they don't contain useful |
381 | // information. |
382 | if (llvm::all_of(F.getParams(), llvm::identity<ParmVarDecl *>())) |
383 | return F; |
384 | } |
385 | |
386 | return {}; |
387 | } |
388 | |
389 | ArrayRef<const ParmVarDecl *> |
390 | maybeDropCxxExplicitObjectParameters(ArrayRef<const ParmVarDecl *> Params) { |
391 | if (!Params.empty() && Params.front()->isExplicitObjectParameter()) |
392 | Params = Params.drop_front(1); |
393 | return Params; |
394 | } |
395 | |
396 | template <typename R> |
397 | std::string joinAndTruncate(const R &Range, size_t MaxLength) { |
398 | std::string Out; |
399 | llvm::raw_string_ostream OS(Out); |
400 | llvm::ListSeparator Sep(", "); |
401 | for (auto &&Element : Range) { |
402 | OS << Sep; |
403 | if (Out.size() + Element.size() >= MaxLength) { |
404 | OS << "..."; |
405 | break; |
406 | } |
407 | OS << Element; |
408 | } |
409 | OS.flush(); |
410 | return Out; |
411 | } |
412 | |
413 | struct Callee { |
414 | // Only one of Decl or Loc is set. |
415 | // Loc is for calls through function pointers. |
416 | const FunctionDecl *Decl = nullptr; |
417 | FunctionProtoTypeLoc Loc; |
418 | }; |
419 | |
420 | class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> { |
421 | public: |
422 | InlayHintVisitor(std::vector<InlayHint> &Results, ParsedAST &AST, |
423 | const Config &Cfg, std::optional<Range> RestrictRange, |
424 | InlayHintOptions HintOptions) |
425 | : Results(Results), AST(AST.getASTContext()), Tokens(AST.getTokens()), |
426 | Cfg(Cfg), RestrictRange(std::move(RestrictRange)), |
427 | MainFileID(AST.getSourceManager().getMainFileID()), |
428 | Resolver(AST.getHeuristicResolver()), |
429 | TypeHintPolicy(this->AST.getPrintingPolicy()), |
430 | HintOptions(HintOptions) { |
431 | bool Invalid = false; |
432 | llvm::StringRef Buf = |
433 | AST.getSourceManager().getBufferData(FID: MainFileID, Invalid: &Invalid); |
434 | MainFileBuf = Invalid ? StringRef{} : Buf; |
435 | |
436 | TypeHintPolicy.SuppressScope = true; // keep type names short |
437 | TypeHintPolicy.AnonymousTagLocations = |
438 | false; // do not print lambda locations |
439 | |
440 | // Not setting PrintCanonicalTypes for "auto" allows |
441 | // SuppressDefaultTemplateArgs (set by default) to have an effect. |
442 | } |
443 | |
444 | bool VisitTypeLoc(TypeLoc TL) { |
445 | if (const auto *DT = llvm::dyn_cast<DecltypeType>(TL.getType())) |
446 | if (QualType UT = DT->getUnderlyingType(); !UT->isDependentType()) |
447 | addTypeHint(R: TL.getSourceRange(), T: UT, Prefix: ": "); |
448 | return true; |
449 | } |
450 | |
451 | bool VisitCXXConstructExpr(CXXConstructExpr *E) { |
452 | // Weed out constructor calls that don't look like a function call with |
453 | // an argument list, by checking the validity of getParenOrBraceRange(). |
454 | // Also weed out std::initializer_list constructors as there are no names |
455 | // for the individual arguments. |
456 | if (!E->getParenOrBraceRange().isValid() || |
457 | E->isStdInitListInitialization()) { |
458 | return true; |
459 | } |
460 | |
461 | Callee Callee; |
462 | Callee.Decl = E->getConstructor(); |
463 | if (!Callee.Decl) |
464 | return true; |
465 | processCall(Callee, RParenOrBraceLoc: E->getParenOrBraceRange().getEnd(), |
466 | Args: {E->getArgs(), E->getNumArgs()}); |
467 | return true; |
468 | } |
469 | |
470 | // Carefully recurse into PseudoObjectExprs, which typically incorporate |
471 | // a syntactic expression and several semantic expressions. |
472 | bool TraversePseudoObjectExpr(PseudoObjectExpr *E) { |
473 | Expr *SyntacticExpr = E->getSyntacticForm(); |
474 | if (isa<CallExpr>(SyntacticExpr)) |
475 | // Since the counterpart semantics usually get the identical source |
476 | // locations as the syntactic one, visiting those would end up presenting |
477 | // confusing hints e.g., __builtin_dump_struct. |
478 | // Thus, only traverse the syntactic forms if this is written as a |
479 | // CallExpr. This leaves the door open in case the arguments in the |
480 | // syntactic form could possibly get parameter names. |
481 | return RecursiveASTVisitor<InlayHintVisitor>::TraverseStmt(SyntacticExpr); |
482 | // We don't want the hints for some of the MS property extensions. |
483 | // e.g. |
484 | // struct S { |
485 | // __declspec(property(get=GetX, put=PutX)) int x[]; |
486 | // void PutX(int y); |
487 | // void Work(int y) { x = y; } // Bad: `x = y: y`. |
488 | // }; |
489 | if (isa<BinaryOperator>(SyntacticExpr)) |
490 | return true; |
491 | // FIXME: Handle other forms of a pseudo object expression. |
492 | return RecursiveASTVisitor<InlayHintVisitor>::TraversePseudoObjectExpr(E); |
493 | } |
494 | |
495 | bool VisitCallExpr(CallExpr *E) { |
496 | if (!Cfg.InlayHints.Parameters) |
497 | return true; |
498 | |
499 | bool IsFunctor = isFunctionObjectCallExpr(E); |
500 | // Do not show parameter hints for user-defined literals or |
501 | // operator calls except for operator(). (Among other reasons, the resulting |
502 | // hints can look awkward, e.g. the expression can itself be a function |
503 | // argument and then we'd get two hints side by side). |
504 | if ((isa<CXXOperatorCallExpr>(E) && !IsFunctor) || |
505 | isa<UserDefinedLiteral>(E)) |
506 | return true; |
507 | |
508 | auto CalleeDecls = Resolver->resolveCalleeOfCallExpr(E); |
509 | if (CalleeDecls.size() != 1) |
510 | return true; |
511 | |
512 | Callee Callee; |
513 | if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecls[0])) |
514 | Callee.Decl = FD; |
515 | else if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(CalleeDecls[0])) |
516 | Callee.Decl = FTD->getTemplatedDecl(); |
517 | else if (FunctionProtoTypeLoc Loc = getPrototypeLoc(E->getCallee())) |
518 | Callee.Loc = Loc; |
519 | else |
520 | return true; |
521 | |
522 | // N4868 [over.call.object]p3 says, |
523 | // The argument list submitted to overload resolution consists of the |
524 | // argument expressions present in the function call syntax preceded by the |
525 | // implied object argument (E). |
526 | // |
527 | // As well as the provision from P0847R7 Deducing This [expr.call]p7: |
528 | // ...If the function is an explicit object member function and there is an |
529 | // implied object argument ([over.call.func]), the list of provided |
530 | // arguments is preceded by the implied object argument for the purposes of |
531 | // this correspondence... |
532 | llvm::ArrayRef<const Expr *> Args = {E->getArgs(), E->getNumArgs()}; |
533 | // We don't have the implied object argument through a function pointer |
534 | // either. |
535 | if (const CXXMethodDecl *Method = |
536 | dyn_cast_or_null<CXXMethodDecl>(Callee.Decl)) |
537 | if (IsFunctor || Method->hasCXXExplicitFunctionObjectParameter()) |
538 | Args = Args.drop_front(N: 1); |
539 | processCall(Callee, RParenOrBraceLoc: E->getRParenLoc(), Args); |
540 | return true; |
541 | } |
542 | |
543 | bool VisitFunctionDecl(FunctionDecl *D) { |
544 | if (auto *FPT = |
545 | llvm::dyn_cast<FunctionProtoType>(D->getType().getTypePtr())) { |
546 | if (!FPT->hasTrailingReturn()) { |
547 | if (auto FTL = D->getFunctionTypeLoc()) |
548 | addReturnTypeHint(D, Range: FTL.getRParenLoc()); |
549 | } |
550 | } |
551 | if (Cfg.InlayHints.BlockEnd && D->isThisDeclarationADefinition()) { |
552 | // We use `printName` here to properly print name of ctor/dtor/operator |
553 | // overload. |
554 | if (const Stmt *Body = D->getBody()) |
555 | addBlockEndHint(BraceRange: Body->getSourceRange(), DeclPrefix: "", Name: printName(AST, *D), OptionalPunctuation: ""); |
556 | } |
557 | return true; |
558 | } |
559 | |
560 | bool VisitForStmt(ForStmt *S) { |
561 | if (Cfg.InlayHints.BlockEnd) { |
562 | std::string Name; |
563 | // Common case: for (int I = 0; I < N; I++). Use "I" as the name. |
564 | if (auto *DS = llvm::dyn_cast_or_null<DeclStmt>(S->getInit()); |
565 | DS && DS->isSingleDecl()) |
566 | Name = getSimpleName(llvm::cast<NamedDecl>(*DS->getSingleDecl())); |
567 | else |
568 | Name = summarizeExpr(E: S->getCond()); |
569 | markBlockEnd(Body: S->getBody(), Label: "for", Name); |
570 | } |
571 | return true; |
572 | } |
573 | |
574 | bool VisitCXXForRangeStmt(CXXForRangeStmt *S) { |
575 | if (Cfg.InlayHints.BlockEnd) |
576 | markBlockEnd(Body: S->getBody(), Label: "for", Name: getSimpleName(*S->getLoopVariable())); |
577 | return true; |
578 | } |
579 | |
580 | bool VisitWhileStmt(WhileStmt *S) { |
581 | if (Cfg.InlayHints.BlockEnd) |
582 | markBlockEnd(Body: S->getBody(), Label: "while", Name: summarizeExpr(E: S->getCond())); |
583 | return true; |
584 | } |
585 | |
586 | bool VisitSwitchStmt(SwitchStmt *S) { |
587 | if (Cfg.InlayHints.BlockEnd) |
588 | markBlockEnd(Body: S->getBody(), Label: "switch", Name: summarizeExpr(E: S->getCond())); |
589 | return true; |
590 | } |
591 | |
592 | // If/else chains are tricky. |
593 | // if (cond1) { |
594 | // } else if (cond2) { |
595 | // } // mark as "cond1" or "cond2"? |
596 | // For now, the answer is neither, just mark as "if". |
597 | // The ElseIf is a different IfStmt that doesn't know about the outer one. |
598 | llvm::DenseSet<const IfStmt *> ElseIfs; // not eligible for names |
599 | bool VisitIfStmt(IfStmt *S) { |
600 | if (Cfg.InlayHints.BlockEnd) { |
601 | if (const auto *ElseIf = llvm::dyn_cast_or_null<IfStmt>(S->getElse())) |
602 | ElseIfs.insert(ElseIf); |
603 | // Don't use markBlockEnd: the relevant range is [then.begin, else.end]. |
604 | if (const auto *EndCS = llvm::dyn_cast<CompoundStmt>( |
605 | S->getElse() ? S->getElse() : S->getThen())) { |
606 | addBlockEndHint( |
607 | {S->getThen()->getBeginLoc(), EndCS->getRBracLoc()}, "if", |
608 | ElseIfs.contains(S) ? "": summarizeExpr(S->getCond()), ""); |
609 | } |
610 | } |
611 | return true; |
612 | } |
613 | |
614 | void markBlockEnd(const Stmt *Body, llvm::StringRef Label, |
615 | llvm::StringRef Name = "") { |
616 | if (const auto *CS = llvm::dyn_cast_or_null<CompoundStmt>(Body)) |
617 | addBlockEndHint(BraceRange: CS->getSourceRange(), DeclPrefix: Label, Name, OptionalPunctuation: ""); |
618 | } |
619 | |
620 | bool VisitTagDecl(TagDecl *D) { |
621 | if (Cfg.InlayHints.BlockEnd && D->isThisDeclarationADefinition()) { |
622 | std::string DeclPrefix = D->getKindName().str(); |
623 | if (const auto *ED = dyn_cast<EnumDecl>(D)) { |
624 | if (ED->isScoped()) |
625 | DeclPrefix += ED->isScopedUsingClassTag() ? " class": " struct"; |
626 | }; |
627 | addBlockEndHint(BraceRange: D->getBraceRange(), DeclPrefix, Name: getSimpleName(*D), OptionalPunctuation: ";"); |
628 | } |
629 | return true; |
630 | } |
631 | |
632 | bool VisitNamespaceDecl(NamespaceDecl *D) { |
633 | if (Cfg.InlayHints.BlockEnd) { |
634 | // For namespace, the range actually starts at the namespace keyword. But |
635 | // it should be fine since it's usually very short. |
636 | addBlockEndHint(BraceRange: D->getSourceRange(), DeclPrefix: "namespace", Name: getSimpleName(*D), OptionalPunctuation: ""); |
637 | } |
638 | return true; |
639 | } |
640 | |
641 | bool VisitLambdaExpr(LambdaExpr *E) { |
642 | FunctionDecl *D = E->getCallOperator(); |
643 | if (!E->hasExplicitResultType()) { |
644 | SourceLocation TypeHintLoc; |
645 | if (!E->hasExplicitParameters()) |
646 | TypeHintLoc = E->getIntroducerRange().getEnd(); |
647 | else if (auto FTL = D->getFunctionTypeLoc()) |
648 | TypeHintLoc = FTL.getRParenLoc(); |
649 | if (TypeHintLoc.isValid()) |
650 | addReturnTypeHint(D, Range: TypeHintLoc); |
651 | } |
652 | return true; |
653 | } |
654 | |
655 | void addReturnTypeHint(FunctionDecl *D, SourceRange Range) { |
656 | auto *AT = D->getReturnType()->getContainedAutoType(); |
657 | if (!AT || AT->getDeducedType().isNull()) |
658 | return; |
659 | addTypeHint(R: Range, T: D->getReturnType(), /*Prefix=*/"-> "); |
660 | } |
661 | |
662 | bool VisitVarDecl(VarDecl *D) { |
663 | // Do not show hints for the aggregate in a structured binding, |
664 | // but show hints for the individual bindings. |
665 | if (auto *DD = dyn_cast<DecompositionDecl>(D)) { |
666 | for (auto *Binding : DD->bindings()) { |
667 | // For structured bindings, print canonical types. This is important |
668 | // because for bindings that use the tuple_element protocol, the |
669 | // non-canonical types would be "tuple_element<I, A>::type". |
670 | if (auto Type = Binding->getType(); |
671 | !Type.isNull() && !Type->isDependentType()) |
672 | addTypeHint(Binding->getLocation(), Type.getCanonicalType(), |
673 | /*Prefix=*/": "); |
674 | } |
675 | return true; |
676 | } |
677 | |
678 | if (auto *AT = D->getType()->getContainedAutoType()) { |
679 | if (AT->isDeduced() && !D->getType()->isDependentType()) { |
680 | // Our current approach is to place the hint on the variable |
681 | // and accordingly print the full type |
682 | // (e.g. for `const auto& x = 42`, print `const int&`). |
683 | // Alternatively, we could place the hint on the `auto` |
684 | // (and then just print the type deduced for the `auto`). |
685 | addTypeHint(R: D->getLocation(), T: D->getType(), /*Prefix=*/": "); |
686 | } |
687 | } |
688 | |
689 | // Handle templates like `int foo(auto x)` with exactly one instantiation. |
690 | if (auto *PVD = llvm::dyn_cast<ParmVarDecl>(D)) { |
691 | if (D->getIdentifier() && PVD->getType()->isDependentType() && |
692 | !getContainedAutoParamType(D->getTypeSourceInfo()->getTypeLoc()) |
693 | .isNull()) { |
694 | if (auto *IPVD = getOnlyParamInstantiation(PVD)) |
695 | addTypeHint(R: D->getLocation(), T: IPVD->getType(), /*Prefix=*/": "); |
696 | } |
697 | } |
698 | |
699 | return true; |
700 | } |
701 | |
702 | ParmVarDecl *getOnlyParamInstantiation(ParmVarDecl *D) { |
703 | auto *TemplateFunction = llvm::dyn_cast<FunctionDecl>(D->getDeclContext()); |
704 | if (!TemplateFunction) |
705 | return nullptr; |
706 | auto *InstantiatedFunction = llvm::dyn_cast_or_null<FunctionDecl>( |
707 | getOnlyInstantiation(TemplateFunction)); |
708 | if (!InstantiatedFunction) |
709 | return nullptr; |
710 | |
711 | unsigned ParamIdx = 0; |
712 | for (auto *Param : TemplateFunction->parameters()) { |
713 | // Can't reason about param indexes in the presence of preceding packs. |
714 | // And if this param is a pack, it may expand to multiple params. |
715 | if (Param->isParameterPack()) |
716 | return nullptr; |
717 | if (Param == D) |
718 | break; |
719 | ++ParamIdx; |
720 | } |
721 | assert(ParamIdx < TemplateFunction->getNumParams() && |
722 | "Couldn't find param in list?"); |
723 | assert(ParamIdx < InstantiatedFunction->getNumParams() && |
724 | "Instantiated function has fewer (non-pack) parameters?"); |
725 | return InstantiatedFunction->getParamDecl(ParamIdx); |
726 | } |
727 | |
728 | bool VisitInitListExpr(InitListExpr *Syn) { |
729 | // We receive the syntactic form here (shouldVisitImplicitCode() is false). |
730 | // This is the one we will ultimately attach designators to. |
731 | // It may have subobject initializers inlined without braces. The *semantic* |
732 | // form of the init-list has nested init-lists for these. |
733 | // getUnwrittenDesignators will look at the semantic form to determine the |
734 | // labels. |
735 | assert(Syn->isSyntacticForm() && "RAV should not visit implicit code!"); |
736 | if (!Cfg.InlayHints.Designators) |
737 | return true; |
738 | if (Syn->isIdiomaticZeroInitializer(LangOpts: AST.getLangOpts())) |
739 | return true; |
740 | llvm::DenseMap<SourceLocation, std::string> Designators = |
741 | tidy::utils::getUnwrittenDesignators(Syn); |
742 | for (const Expr *Init : Syn->inits()) { |
743 | if (llvm::isa<DesignatedInitExpr>(Init)) |
744 | continue; |
745 | auto It = Designators.find(Init->getBeginLoc()); |
746 | if (It != Designators.end() && |
747 | !isPrecededByParamNameComment(E: Init, ParamName: It->second)) |
748 | addDesignatorHint(R: Init->getSourceRange(), Text: It->second); |
749 | } |
750 | return true; |
751 | } |
752 | |
753 | // FIXME: Handle RecoveryExpr to try to hint some invalid calls. |
754 | |
755 | private: |
756 | using NameVec = SmallVector<StringRef, 8>; |
757 | |
758 | void processCall(Callee Callee, SourceLocation RParenOrBraceLoc, |
759 | llvm::ArrayRef<const Expr *> Args) { |
760 | assert(Callee.Decl || Callee.Loc); |
761 | |
762 | if ((!Cfg.InlayHints.Parameters && !Cfg.InlayHints.DefaultArguments) || |
763 | Args.size() == 0) |
764 | return; |
765 | |
766 | // The parameter name of a move or copy constructor is not very interesting. |
767 | if (Callee.Decl) |
768 | if (auto *Ctor = dyn_cast<CXXConstructorDecl>(Callee.Decl)) |
769 | if (Ctor->isCopyOrMoveConstructor()) |
770 | return; |
771 | |
772 | SmallVector<std::string> FormattedDefaultArgs; |
773 | bool HasNonDefaultArgs = false; |
774 | |
775 | ArrayRef<const ParmVarDecl *> Params, ForwardedParams; |
776 | // Resolve parameter packs to their forwarded parameter |
777 | SmallVector<const ParmVarDecl *> ForwardedParamsStorage; |
778 | if (Callee.Decl) { |
779 | Params = maybeDropCxxExplicitObjectParameters(Callee.Decl->parameters()); |
780 | ForwardedParamsStorage = resolveForwardingParameters(Callee.Decl); |
781 | ForwardedParams = |
782 | maybeDropCxxExplicitObjectParameters(ForwardedParamsStorage); |
783 | } else { |
784 | Params = maybeDropCxxExplicitObjectParameters(Callee.Loc.getParams()); |
785 | ForwardedParams = {Params.begin(), Params.end()}; |
786 | } |
787 | |
788 | NameVec ParameterNames = chooseParameterNames(Parameters: ForwardedParams); |
789 | |
790 | // Exclude setters (i.e. functions with one argument whose name begins with |
791 | // "set"), and builtins like std::move/forward/... as their parameter name |
792 | // is also not likely to be interesting. |
793 | if (Callee.Decl && |
794 | (isSetter(Callee: Callee.Decl, ParamNames: ParameterNames) || isSimpleBuiltin(Callee: Callee.Decl))) |
795 | return; |
796 | |
797 | for (size_t I = 0; I < ParameterNames.size() && I < Args.size(); ++I) { |
798 | // Pack expansion expressions cause the 1:1 mapping between arguments and |
799 | // parameters to break down, so we don't add further inlay hints if we |
800 | // encounter one. |
801 | if (isa<PackExpansionExpr>(Args[I])) { |
802 | break; |
803 | } |
804 | |
805 | StringRef Name = ParameterNames[I]; |
806 | const bool NameHint = |
807 | shouldHintName(Arg: Args[I], ParamName: Name) && Cfg.InlayHints.Parameters; |
808 | const bool ReferenceHint = |
809 | shouldHintReference(Param: Params[I], ForwardedParam: ForwardedParams[I]) && |
810 | Cfg.InlayHints.Parameters; |
811 | |
812 | const bool IsDefault = isa<CXXDefaultArgExpr>(Args[I]); |
813 | HasNonDefaultArgs |= !IsDefault; |
814 | if (IsDefault) { |
815 | if (Cfg.InlayHints.DefaultArguments) { |
816 | const auto SourceText = Lexer::getSourceText( |
817 | Range: CharSourceRange::getTokenRange(Params[I]->getDefaultArgRange()), |
818 | SM: AST.getSourceManager(), LangOpts: AST.getLangOpts()); |
819 | const auto Abbrev = |
820 | (SourceText.size() > Cfg.InlayHints.TypeNameLimit || |
821 | SourceText.contains("\n")) |
822 | ? "..." |
823 | : SourceText; |
824 | if (NameHint) |
825 | FormattedDefaultArgs.emplace_back( |
826 | llvm::formatv("{0}: {1}", Name, Abbrev)); |
827 | else |
828 | FormattedDefaultArgs.emplace_back(llvm::formatv("{0}", Abbrev)); |
829 | } |
830 | } else if (NameHint || ReferenceHint) { |
831 | addInlayHint(Args[I]->getSourceRange(), HintSide::Left, |
832 | InlayHintKind::Parameter, ReferenceHint ? "&": "", |
833 | NameHint ? Name : "", ": "); |
834 | } |
835 | } |
836 | |
837 | if (!FormattedDefaultArgs.empty()) { |
838 | std::string Hint = |
839 | joinAndTruncate(FormattedDefaultArgs, Cfg.InlayHints.TypeNameLimit); |
840 | addInlayHint(R: SourceRange{RParenOrBraceLoc}, Side: HintSide::Left, |
841 | Kind: InlayHintKind::DefaultArgument, |
842 | Prefix: HasNonDefaultArgs ? ", ": "", Label: Hint, Suffix: ""); |
843 | } |
844 | } |
845 | |
846 | static bool isSetter(const FunctionDecl *Callee, const NameVec &ParamNames) { |
847 | if (ParamNames.size() != 1) |
848 | return false; |
849 | |
850 | StringRef Name = getSimpleName(*Callee); |
851 | if (!Name.starts_with_insensitive(Prefix: "set")) |
852 | return false; |
853 | |
854 | // In addition to checking that the function has one parameter and its |
855 | // name starts with "set", also check that the part after "set" matches |
856 | // the name of the parameter (ignoring case). The idea here is that if |
857 | // the parameter name differs, it may contain extra information that |
858 | // may be useful to show in a hint, as in: |
859 | // void setTimeout(int timeoutMillis); |
860 | // This currently doesn't handle cases where params use snake_case |
861 | // and functions don't, e.g. |
862 | // void setExceptionHandler(EHFunc exception_handler); |
863 | // We could improve this by replacing `equals_insensitive` with some |
864 | // `sloppy_equals` which ignores case and also skips underscores. |
865 | StringRef WhatItIsSetting = Name.substr(Start: 3).ltrim(Chars: "_"); |
866 | return WhatItIsSetting.equals_insensitive(RHS: ParamNames[0]); |
867 | } |
868 | |
869 | // Checks if the callee is one of the builtins |
870 | // addressof, as_const, forward, move(_if_noexcept) |
871 | static bool isSimpleBuiltin(const FunctionDecl *Callee) { |
872 | switch (Callee->getBuiltinID()) { |
873 | case Builtin::BIaddressof: |
874 | case Builtin::BIas_const: |
875 | case Builtin::BIforward: |
876 | case Builtin::BImove: |
877 | case Builtin::BImove_if_noexcept: |
878 | return true; |
879 | default: |
880 | return false; |
881 | } |
882 | } |
883 | |
884 | bool shouldHintName(const Expr *Arg, StringRef ParamName) { |
885 | if (ParamName.empty()) |
886 | return false; |
887 | |
888 | // If the argument expression is a single name and it matches the |
889 | // parameter name exactly, omit the name hint. |
890 | if (ParamName == getSpelledIdentifier(E: Arg)) |
891 | return false; |
892 | |
893 | // Exclude argument expressions preceded by a /*paramName*/. |
894 | if (isPrecededByParamNameComment(E: Arg, ParamName)) |
895 | return false; |
896 | |
897 | return true; |
898 | } |
899 | |
900 | bool shouldHintReference(const ParmVarDecl *Param, |
901 | const ParmVarDecl *ForwardedParam) { |
902 | // We add a & hint only when the argument is passed as mutable reference. |
903 | // For parameters that are not part of an expanded pack, this is |
904 | // straightforward. For expanded pack parameters, it's likely that they will |
905 | // be forwarded to another function. In this situation, we only want to add |
906 | // the reference hint if the argument is actually being used via mutable |
907 | // reference. This means we need to check |
908 | // 1. whether the value category of the argument is preserved, i.e. each |
909 | // pack expansion uses std::forward correctly. |
910 | // 2. whether the argument is ever copied/cast instead of passed |
911 | // by-reference |
912 | // Instead of checking this explicitly, we use the following proxy: |
913 | // 1. the value category can only change from rvalue to lvalue during |
914 | // forwarding, so checking whether both the parameter of the forwarding |
915 | // function and the forwarded function are lvalue references detects such |
916 | // a conversion. |
917 | // 2. if the argument is copied/cast somewhere in the chain of forwarding |
918 | // calls, it can only be passed on to an rvalue reference or const lvalue |
919 | // reference parameter. Thus if the forwarded parameter is a mutable |
920 | // lvalue reference, it cannot have been copied/cast to on the way. |
921 | // Additionally, we should not add a reference hint if the forwarded |
922 | // parameter was only partially resolved, i.e. points to an expanded pack |
923 | // parameter, since we do not know how it will be used eventually. |
924 | auto Type = Param->getType(); |
925 | auto ForwardedType = ForwardedParam->getType(); |
926 | return Type->isLValueReferenceType() && |
927 | ForwardedType->isLValueReferenceType() && |
928 | !ForwardedType.getNonReferenceType().isConstQualified() && |
929 | !isExpandedFromParameterPack(D: ForwardedParam); |
930 | } |
931 | |
932 | // Checks if "E" is spelled in the main file and preceded by a C-style comment |
933 | // whose contents match ParamName (allowing for whitespace and an optional "=" |
934 | // at the end. |
935 | bool isPrecededByParamNameComment(const Expr *E, StringRef ParamName) { |
936 | auto &SM = AST.getSourceManager(); |
937 | auto FileLoc = SM.getFileLoc(Loc: E->getBeginLoc()); |
938 | auto Decomposed = SM.getDecomposedLoc(Loc: FileLoc); |
939 | if (Decomposed.first != MainFileID) |
940 | return false; |
941 | |
942 | StringRef SourcePrefix = MainFileBuf.substr(Start: 0, N: Decomposed.second); |
943 | // Allow whitespace between comment and expression. |
944 | SourcePrefix = SourcePrefix.rtrim(); |
945 | // Check for comment ending. |
946 | if (!SourcePrefix.consume_back(Suffix: "*/")) |
947 | return false; |
948 | // Ignore some punctuation and whitespace around comment. |
949 | // In particular this allows designators to match nicely. |
950 | llvm::StringLiteral IgnoreChars = " =."; |
951 | SourcePrefix = SourcePrefix.rtrim(Chars: IgnoreChars); |
952 | ParamName = ParamName.trim(Chars: IgnoreChars); |
953 | // Other than that, the comment must contain exactly ParamName. |
954 | if (!SourcePrefix.consume_back(Suffix: ParamName)) |
955 | return false; |
956 | SourcePrefix = SourcePrefix.rtrim(Chars: IgnoreChars); |
957 | return SourcePrefix.ends_with(Suffix: "/*"); |
958 | } |
959 | |
960 | // If "E" spells a single unqualified identifier, return that name. |
961 | // Otherwise, return an empty string. |
962 | static StringRef getSpelledIdentifier(const Expr *E) { |
963 | E = E->IgnoreUnlessSpelledInSource(); |
964 | |
965 | if (auto *DRE = dyn_cast<DeclRefExpr>(E)) |
966 | if (!DRE->getQualifier()) |
967 | return getSimpleName(*DRE->getDecl()); |
968 | |
969 | if (auto *ME = dyn_cast<MemberExpr>(E)) |
970 | if (!ME->getQualifier() && ME->isImplicitAccess()) |
971 | return getSimpleName(*ME->getMemberDecl()); |
972 | |
973 | return {}; |
974 | } |
975 | |
976 | NameVec chooseParameterNames(ArrayRef<const ParmVarDecl *> Parameters) { |
977 | NameVec ParameterNames; |
978 | for (const auto *P : Parameters) { |
979 | if (isExpandedFromParameterPack(P)) { |
980 | // If we haven't resolved a pack paramater (e.g. foo(Args... args)) to a |
981 | // non-pack parameter, then hinting as foo(args: 1, args: 2, args: 3) is |
982 | // unlikely to be useful. |
983 | ParameterNames.emplace_back(); |
984 | } else { |
985 | auto SimpleName = getSimpleName(*P); |
986 | // If the parameter is unnamed in the declaration: |
987 | // attempt to get its name from the definition |
988 | if (SimpleName.empty()) { |
989 | if (const auto *PD = getParamDefinition(P)) { |
990 | SimpleName = getSimpleName(*PD); |
991 | } |
992 | } |
993 | ParameterNames.emplace_back(SimpleName); |
994 | } |
995 | } |
996 | |
997 | // Standard library functions often have parameter names that start |
998 | // with underscores, which makes the hints noisy, so strip them out. |
999 | for (auto &Name : ParameterNames) |
1000 | stripLeadingUnderscores(Name); |
1001 | |
1002 | return ParameterNames; |
1003 | } |
1004 | |
1005 | // for a ParmVarDecl from a function declaration, returns the corresponding |
1006 | // ParmVarDecl from the definition if possible, nullptr otherwise. |
1007 | static const ParmVarDecl *getParamDefinition(const ParmVarDecl *P) { |
1008 | if (auto *Callee = dyn_cast<FunctionDecl>(P->getDeclContext())) { |
1009 | if (auto *Def = Callee->getDefinition()) { |
1010 | auto I = std::distance(Callee->param_begin(), |
1011 | llvm::find(Callee->parameters(), P)); |
1012 | if (I < (int)Callee->getNumParams()) { |
1013 | return Def->getParamDecl(I); |
1014 | } |
1015 | } |
1016 | } |
1017 | return nullptr; |
1018 | } |
1019 | |
1020 | // We pass HintSide rather than SourceLocation because we want to ensure |
1021 | // it is in the same file as the common file range. |
1022 | void addInlayHint(SourceRange R, HintSide Side, InlayHintKind Kind, |
1023 | llvm::StringRef Prefix, llvm::StringRef Label, |
1024 | llvm::StringRef Suffix) { |
1025 | auto LSPRange = getHintRange(R); |
1026 | if (!LSPRange) |
1027 | return; |
1028 | |
1029 | addInlayHint(LSPRange: *LSPRange, Side, Kind, Prefix, Label, Suffix); |
1030 | } |
1031 | |
1032 | void addInlayHint(Range LSPRange, HintSide Side, InlayHintKind Kind, |
1033 | llvm::StringRef Prefix, llvm::StringRef Label, |
1034 | llvm::StringRef Suffix) { |
1035 | // We shouldn't get as far as adding a hint if the category is disabled. |
1036 | // We'd like to disable as much of the analysis as possible above instead. |
1037 | // Assert in debug mode but add a dynamic check in production. |
1038 | assert(Cfg.InlayHints.Enabled && "Shouldn't get here if disabled!"); |
1039 | switch (Kind) { |
1040 | #define CHECK_KIND(Enumerator, ConfigProperty) \ |
1041 | case InlayHintKind::Enumerator: \ |
1042 | assert(Cfg.InlayHints.ConfigProperty && \ |
1043 | "Shouldn't get here if kind is disabled!"); \ |
1044 | if (!Cfg.InlayHints.ConfigProperty) \ |
1045 | return; \ |
1046 | break |
1047 | CHECK_KIND(Parameter, Parameters); |
1048 | CHECK_KIND(Type, DeducedTypes); |
1049 | CHECK_KIND(Designator, Designators); |
1050 | CHECK_KIND(BlockEnd, BlockEnd); |
1051 | CHECK_KIND(DefaultArgument, DefaultArguments); |
1052 | #undef CHECK_KIND |
1053 | } |
1054 | |
1055 | Position LSPPos = Side == HintSide::Left ? LSPRange.start : LSPRange.end; |
1056 | if (RestrictRange && |
1057 | (LSPPos < RestrictRange->start || !(LSPPos < RestrictRange->end))) |
1058 | return; |
1059 | bool PadLeft = Prefix.consume_front(Prefix: " "); |
1060 | bool PadRight = Suffix.consume_back(Suffix: " "); |
1061 | Results.push_back(InlayHint{LSPPos, |
1062 | /*label=*/{(Prefix + Label + Suffix).str()}, |
1063 | Kind, PadLeft, PadRight, LSPRange}); |
1064 | } |
1065 | |
1066 | // Get the range of the main file that *exactly* corresponds to R. |
1067 | std::optional<Range> getHintRange(SourceRange R) { |
1068 | const auto &SM = AST.getSourceManager(); |
1069 | auto Spelled = Tokens.spelledForExpanded(Tokens.expandedTokens(R)); |
1070 | // TokenBuffer will return null if e.g. R corresponds to only part of a |
1071 | // macro expansion. |
1072 | if (!Spelled || Spelled->empty()) |
1073 | return std::nullopt; |
1074 | // Hint must be within the main file, not e.g. a non-preamble include. |
1075 | if (SM.getFileID(Spelled->front().location()) != SM.getMainFileID() || |
1076 | SM.getFileID(Spelled->back().location()) != SM.getMainFileID()) |
1077 | return std::nullopt; |
1078 | return Range{sourceLocToPosition(SM, Spelled->front().location()), |
1079 | sourceLocToPosition(SM, Spelled->back().endLocation())}; |
1080 | } |
1081 | |
1082 | void addTypeHint(SourceRange R, QualType T, llvm::StringRef Prefix) { |
1083 | if (!Cfg.InlayHints.DeducedTypes || T.isNull()) |
1084 | return; |
1085 | |
1086 | // The sugared type is more useful in some cases, and the canonical |
1087 | // type in other cases. |
1088 | auto Desugared = maybeDesugar(AST, QT: T); |
1089 | std::string TypeName = Desugared.getAsString(Policy: TypeHintPolicy); |
1090 | if (T != Desugared && !shouldPrintTypeHint(TypeName)) { |
1091 | // If the desugared type is too long to display, fallback to the sugared |
1092 | // type. |
1093 | TypeName = T.getAsString(Policy: TypeHintPolicy); |
1094 | } |
1095 | if (shouldPrintTypeHint(TypeName)) |
1096 | addInlayHint(R, Side: HintSide::Right, Kind: InlayHintKind::Type, Prefix, Label: TypeName, |
1097 | /*Suffix=*/""); |
1098 | } |
1099 | |
1100 | void addDesignatorHint(SourceRange R, llvm::StringRef Text) { |
1101 | addInlayHint(R, Side: HintSide::Left, Kind: InlayHintKind::Designator, |
1102 | /*Prefix=*/"", Label: Text, /*Suffix=*/ "="); |
1103 | } |
1104 | |
1105 | bool shouldPrintTypeHint(llvm::StringRef TypeName) const noexcept { |
1106 | return Cfg.InlayHints.TypeNameLimit == 0 || |
1107 | TypeName.size() < Cfg.InlayHints.TypeNameLimit; |
1108 | } |
1109 | |
1110 | void addBlockEndHint(SourceRange BraceRange, StringRef DeclPrefix, |
1111 | StringRef Name, StringRef OptionalPunctuation) { |
1112 | auto HintRange = computeBlockEndHintRange(BraceRange, OptionalPunctuation); |
1113 | if (!HintRange) |
1114 | return; |
1115 | |
1116 | std::string Label = DeclPrefix.str(); |
1117 | if (!Label.empty() && !Name.empty()) |
1118 | Label += ' '; |
1119 | Label += Name; |
1120 | |
1121 | constexpr unsigned HintMaxLengthLimit = 60; |
1122 | if (Label.length() > HintMaxLengthLimit) |
1123 | return; |
1124 | |
1125 | addInlayHint(LSPRange: *HintRange, Side: HintSide::Right, Kind: InlayHintKind::BlockEnd, Prefix: " // ", |
1126 | Label, Suffix: ""); |
1127 | } |
1128 | |
1129 | // Compute the LSP range to attach the block end hint to, if any allowed. |
1130 | // 1. "}" is the last non-whitespace character on the line. The range of "}" |
1131 | // is returned. |
1132 | // 2. After "}", if the trimmed trailing text is exactly |
1133 | // `OptionalPunctuation`, say ";". The range of "} ... ;" is returned. |
1134 | // Otherwise, the hint shouldn't be shown. |
1135 | std::optional<Range> computeBlockEndHintRange(SourceRange BraceRange, |
1136 | StringRef OptionalPunctuation) { |
1137 | |
1138 | auto &SM = AST.getSourceManager(); |
1139 | auto [BlockBeginFileId, BlockBeginOffset] = |
1140 | SM.getDecomposedLoc(SM.getFileLoc(Loc: BraceRange.getBegin())); |
1141 | auto RBraceLoc = SM.getFileLoc(Loc: BraceRange.getEnd()); |
1142 | auto [RBraceFileId, RBraceOffset] = SM.getDecomposedLoc(RBraceLoc); |
1143 | |
1144 | // Because we need to check the block satisfies the minimum line limit, we |
1145 | // require both source location to be in the main file. This prevents hint |
1146 | // to be shown in weird cases like '{' is actually in a "#include", but it's |
1147 | // rare anyway. |
1148 | if (BlockBeginFileId != MainFileID || RBraceFileId != MainFileID) |
1149 | return std::nullopt; |
1150 | |
1151 | StringRef RestOfLine = MainFileBuf.substr(Start: RBraceOffset).split('\n').first; |
1152 | if (!RestOfLine.starts_with(Prefix: "}")) |
1153 | return std::nullopt; |
1154 | |
1155 | StringRef TrimmedTrailingText = RestOfLine.drop_front().trim(); |
1156 | if (!TrimmedTrailingText.empty() && |
1157 | TrimmedTrailingText != OptionalPunctuation) |
1158 | return std::nullopt; |
1159 | |
1160 | auto BlockBeginLine = SM.getLineNumber(FID: BlockBeginFileId, FilePos: BlockBeginOffset); |
1161 | auto RBraceLine = SM.getLineNumber(FID: RBraceFileId, FilePos: RBraceOffset); |
1162 | |
1163 | // Don't show hint on trivial blocks like `class X {};` |
1164 | if (BlockBeginLine + HintOptions.HintMinLineLimit - 1 > RBraceLine) |
1165 | return std::nullopt; |
1166 | |
1167 | // This is what we attach the hint to, usually "}" or "};". |
1168 | StringRef HintRangeText = RestOfLine.take_front( |
1169 | N: TrimmedTrailingText.empty() |
1170 | ? 1 |
1171 | : TrimmedTrailingText.bytes_end() - RestOfLine.bytes_begin()); |
1172 | |
1173 | Position HintStart = sourceLocToPosition(SM, Loc: RBraceLoc); |
1174 | Position HintEnd = sourceLocToPosition( |
1175 | SM, Loc: RBraceLoc.getLocWithOffset(Offset: HintRangeText.size())); |
1176 | return Range{.start: HintStart, .end: HintEnd}; |
1177 | } |
1178 | |
1179 | static bool isFunctionObjectCallExpr(CallExpr *E) noexcept { |
1180 | if (auto *CallExpr = dyn_cast<CXXOperatorCallExpr>(E)) |
1181 | return CallExpr->getOperator() == OverloadedOperatorKind::OO_Call; |
1182 | return false; |
1183 | } |
1184 | |
1185 | std::vector<InlayHint> &Results; |
1186 | ASTContext &AST; |
1187 | const syntax::TokenBuffer &Tokens; |
1188 | const Config &Cfg; |
1189 | std::optional<Range> RestrictRange; |
1190 | FileID MainFileID; |
1191 | StringRef MainFileBuf; |
1192 | const HeuristicResolver *Resolver; |
1193 | PrintingPolicy TypeHintPolicy; |
1194 | InlayHintOptions HintOptions; |
1195 | }; |
1196 | |
1197 | } // namespace |
1198 | |
1199 | std::vector<InlayHint> inlayHints(ParsedAST &AST, |
1200 | std::optional<Range> RestrictRange, |
1201 | InlayHintOptions HintOptions) { |
1202 | std::vector<InlayHint> Results; |
1203 | const auto &Cfg = Config::current(); |
1204 | if (!Cfg.InlayHints.Enabled) |
1205 | return Results; |
1206 | InlayHintVisitor Visitor(Results, AST, Cfg, std::move(RestrictRange), |
1207 | HintOptions); |
1208 | Visitor.TraverseAST(AST.getASTContext()); |
1209 | |
1210 | // De-duplicate hints. Duplicates can sometimes occur due to e.g. explicit |
1211 | // template instantiations. |
1212 | llvm::sort(Results); |
1213 | Results.erase(llvm::unique(Results), Results.end()); |
1214 | |
1215 | return Results; |
1216 | } |
1217 | |
1218 | } // namespace clangd |
1219 | } // namespace clang |
1220 |
Definitions
- HintSide
- stripLeadingUnderscores
- getDeclForTypeImpl
- getDeclForTypeImpl
- getDeclForType
- getSimpleName
- getSimpleName
- getSimpleName
- summarizeExpr
- isSugaredTemplateParameter
- desugar
- maybeDesugar
- getPrototypeLoc
- maybeDropCxxExplicitObjectParameters
- joinAndTruncate
- Callee
- InlayHintVisitor
- InlayHintVisitor
- VisitTypeLoc
- VisitCXXConstructExpr
- TraversePseudoObjectExpr
- VisitCallExpr
- VisitFunctionDecl
- VisitForStmt
- VisitCXXForRangeStmt
- VisitWhileStmt
- VisitSwitchStmt
- VisitIfStmt
- markBlockEnd
- VisitTagDecl
- VisitNamespaceDecl
- VisitLambdaExpr
- addReturnTypeHint
- VisitVarDecl
- getOnlyParamInstantiation
- VisitInitListExpr
- processCall
- isSetter
- isSimpleBuiltin
- shouldHintName
- shouldHintReference
- isPrecededByParamNameComment
- getSpelledIdentifier
- chooseParameterNames
- getParamDefinition
- addInlayHint
- addInlayHint
- getHintRange
- addTypeHint
- addDesignatorHint
- shouldPrintTypeHint
- addBlockEndHint
- computeBlockEndHintRange
- isFunctionObjectCallExpr
Improve your Profiling and Debugging skills
Find out more