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