blob: 6b9c8b1eee54fb0ee6e0581848f629ece5a19bcc [file] [log] [blame]
//===--- InlayHints.cpp ------------------------------------------*- C++-*-===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#include "InlayHints.h"
#include "HeuristicResolver.h"
#include "ParsedAST.h"
#include "support/Logger.h"
#include "clang/AST/DeclarationName.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/Support/raw_ostream.h"
namespace clang {
namespace clangd {
class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
InlayHintVisitor(std::vector<InlayHint> &Results, ParsedAST &AST)
: Results(Results), AST(AST.getASTContext()),
StructuredBindingPolicy(this->AST.getPrintingPolicy()) {
bool Invalid = false;
llvm::StringRef Buf =
AST.getSourceManager().getBufferData(MainFileID, &Invalid);
MainFileBuf = Invalid ? StringRef{} : Buf;
TypeHintPolicy.SuppressScope = true; // keep type names short
TypeHintPolicy.AnonymousTagLocations =
false; // do not print lambda locations
// For structured bindings, print canonical types. This is important because
// for bindings that use the tuple_element protocol, the non-canonical types
// would be "tuple_element<I, A>::type".
// For "auto", we often prefer sugared types.
// Not setting PrintCanonicalTypes for "auto" allows
// SuppressDefaultTemplateArgs (set by default) to have an effect.
StructuredBindingPolicy = TypeHintPolicy;
StructuredBindingPolicy.PrintCanonicalTypes = true;
bool VisitCXXConstructExpr(CXXConstructExpr *E) {
// Weed out constructor calls that don't look like a function call with
// an argument list, by checking the validity of getParenOrBraceRange().
// Also weed out std::initializer_list constructors as there are no names
// for the individual arguments.
if (!E->getParenOrBraceRange().isValid() ||
E->isStdInitListInitialization()) {
return true;
processCall(E->getParenOrBraceRange().getBegin(), E->getConstructor(),
{E->getArgs(), E->getNumArgs()});
return true;
bool VisitCallExpr(CallExpr *E) {
// Do not show parameter hints for operator calls written using operator
// syntax or user-defined literals. (Among other reasons, the resulting
// hints can look awkard, e.g. the expression can itself be a function
// argument and then we'd get two hints side by side).
if (isa<CXXOperatorCallExpr>(E) || isa<UserDefinedLiteral>(E))
return true;
auto CalleeDecls = Resolver->resolveCalleeOfCallExpr(E);
if (CalleeDecls.size() != 1)
return true;
const FunctionDecl *Callee = nullptr;
if (const auto *FD = dyn_cast<FunctionDecl>(CalleeDecls[0]))
Callee = FD;
else if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(CalleeDecls[0]))
Callee = FTD->getTemplatedDecl();
if (!Callee)
return true;
processCall(E->getRParenLoc(), Callee, {E->getArgs(), E->getNumArgs()});
return true;
bool VisitFunctionDecl(FunctionDecl *D) {
if (auto *AT = D->getReturnType()->getContainedAutoType()) {
QualType Deduced = AT->getDeducedType();
if (!Deduced.isNull()) {
addTypeHint(D->getFunctionTypeLoc().getRParenLoc(), D->getReturnType(),
"-> ");
return true;
bool VisitVarDecl(VarDecl *D) {
// Do not show hints for the aggregate in a structured binding,
// but show hints for the individual bindings.
if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
for (auto *Binding : DD->bindings()) {
addTypeHint(Binding->getLocation(), Binding->getType(), ": ",
return true;
if (D->getType()->getContainedAutoType()) {
if (!D->getType()->isDependentType()) {
// Our current approach is to place the hint on the variable
// and accordingly print the full type
// (e.g. for `const auto& x = 42`, print `const int&`).
// Alternatively, we could place the hint on the `auto`
// (and then just print the type deduced for the `auto`).
addTypeHint(D->getLocation(), D->getType(), ": ");
return true;
// FIXME: Handle RecoveryExpr to try to hint some invalid calls.
using NameVec = SmallVector<StringRef, 8>;
// The purpose of Anchor is to deal with macros. It should be the call's
// opening or closing parenthesis or brace. (Always using the opening would
// make more sense but CallExpr only exposes the closing.) We heuristically
// assume that if this location does not come from a macro definition, then
// the entire argument list likely appears in the main file and can be hinted.
void processCall(SourceLocation Anchor, const FunctionDecl *Callee,
llvm::ArrayRef<const Expr *const> Args) {
if (Args.size() == 0 || !Callee)
// If the anchor location comes from a macro defintion, there's nowhere to
// put hints.
if (!AST.getSourceManager().getTopMacroCallerLoc(Anchor).isFileID())
// The parameter name of a move or copy constructor is not very interesting.
if (auto *Ctor = dyn_cast<CXXConstructorDecl>(Callee))
if (Ctor->isCopyOrMoveConstructor())
// Don't show hints for variadic parameters.
size_t FixedParamCount = getFixedParamCount(Callee);
size_t ArgCount = std::min(FixedParamCount, Args.size());
NameVec ParameterNames = chooseParameterNames(Callee, ArgCount);
// Exclude setters (i.e. functions with one argument whose name begins with
// "set"), as their parameter name is also not likely to be interesting.
if (isSetter(Callee, ParameterNames))
for (size_t I = 0; I < ArgCount; ++I) {
StringRef Name = ParameterNames[I];
if (!shouldHint(Args[I], Name))
addInlayHint(Args[I]->getSourceRange(), InlayHintKind::ParameterHint,
Name.str() + ": ");
static bool isSetter(const FunctionDecl *Callee, const NameVec &ParamNames) {
if (ParamNames.size() != 1)
return false;
StringRef Name = getSimpleName(*Callee);
if (!Name.startswith_insensitive("set"))
return false;
// In addition to checking that the function has one parameter and its
// name starts with "set", also check that the part after "set" matches
// the name of the parameter (ignoring case). The idea here is that if
// the parameter name differs, it may contain extra information that
// may be useful to show in a hint, as in:
// void setTimeout(int timeoutMillis);
// This currently doesn't handle cases where params use snake_case
// and functions don't, e.g.
// void setExceptionHandler(EHFunc exception_handler);
// We could improve this by replacing `equals_insensitive` with some
// `sloppy_equals` which ignores case and also skips underscores.
StringRef WhatItIsSetting = Name.substr(3).ltrim("_");
return WhatItIsSetting.equals_insensitive(ParamNames[0]);
bool shouldHint(const Expr *Arg, StringRef ParamName) {
if (ParamName.empty())
return false;
// If the argument expression is a single name and it matches the
// parameter name exactly, omit the hint.
if (ParamName == getSpelledIdentifier(Arg))
return false;
// Exclude argument expressions preceded by a /*paramName*/.
if (isPrecededByParamNameComment(Arg, ParamName))
return false;
return true;
// Checks if "E" is spelled in the main file and preceded by a C-style comment
// whose contents match ParamName (allowing for whitespace and an optional "="
// at the end.
bool isPrecededByParamNameComment(const Expr *E, StringRef ParamName) {
auto &SM = AST.getSourceManager();
auto ExprStartLoc = SM.getTopMacroCallerLoc(E->getBeginLoc());
auto Decomposed = SM.getDecomposedLoc(ExprStartLoc);
if (Decomposed.first != MainFileID)
return false;
StringRef SourcePrefix = MainFileBuf.substr(0, Decomposed.second);
// Allow whitespace between comment and expression.
SourcePrefix = SourcePrefix.rtrim();
// Check for comment ending.
if (!SourcePrefix.consume_back("*/"))
return false;
// Allow whitespace and "=" at end of comment.
SourcePrefix = SourcePrefix.rtrim().rtrim('=').rtrim();
// Other than that, the comment must contain exactly ParamName.
if (!SourcePrefix.consume_back(ParamName))
return false;
return SourcePrefix.rtrim().endswith("/*");
// If "E" spells a single unqualified identifier, return that name.
// Otherwise, return an empty string.
static StringRef getSpelledIdentifier(const Expr *E) {
E = E->IgnoreUnlessSpelledInSource();
if (auto *DRE = dyn_cast<DeclRefExpr>(E))
if (!DRE->getQualifier())
return getSimpleName(*DRE->getDecl());
if (auto *ME = dyn_cast<MemberExpr>(E))
if (!ME->getQualifier() && ME->isImplicitAccess())
return getSimpleName(*ME->getMemberDecl());
return {};
NameVec chooseParameterNames(const FunctionDecl *Callee, size_t ArgCount) {
// The current strategy here is to use all the parameter names from the
// canonical declaration, unless they're all empty, in which case we
// use all the parameter names from the definition (in present in the
// translation unit).
// We could try a bit harder, e.g.:
// - try all re-declarations, not just canonical + definition
// - fall back arg-by-arg rather than wholesale
NameVec ParameterNames = getParameterNamesForDecl(Callee, ArgCount);
if (llvm::all_of(ParameterNames, std::mem_fn(&StringRef::empty))) {
if (const FunctionDecl *Def = Callee->getDefinition()) {
ParameterNames = getParameterNamesForDecl(Def, ArgCount);
assert(ParameterNames.size() == ArgCount);
// Standard library functions often have parameter names that start
// with underscores, which makes the hints noisy, so strip them out.
for (auto &Name : ParameterNames)
return ParameterNames;
static void stripLeadingUnderscores(StringRef &Name) {
Name = Name.ltrim('_');
// Return the number of fixed parameters Function has, that is, not counting
// parameters that are variadic (instantiated from a parameter pack) or
// C-style varargs.
static size_t getFixedParamCount(const FunctionDecl *Function) {
if (FunctionTemplateDecl *Template = Function->getPrimaryTemplate()) {
FunctionDecl *F = Template->getTemplatedDecl();
size_t Result = 0;
for (ParmVarDecl *Parm : F->parameters()) {
if (Parm->isParameterPack()) {
return Result;
// C-style varargs don't need special handling, they're already
// not included in getNumParams().
return Function->getNumParams();
static StringRef getSimpleName(const NamedDecl &D) {
if (IdentifierInfo *Ident = D.getDeclName().getAsIdentifierInfo()) {
return Ident->getName();
return StringRef();
NameVec getParameterNamesForDecl(const FunctionDecl *Function,
size_t ArgCount) {
NameVec Result;
for (size_t I = 0; I < ArgCount; ++I) {
const ParmVarDecl *Parm = Function->getParamDecl(I);
return Result;
void addInlayHint(SourceRange R, InlayHintKind Kind, llvm::StringRef Label) {
auto FileRange =
toHalfOpenFileRange(AST.getSourceManager(), AST.getLangOpts(), R);
if (!FileRange)
// The hint may be in a file other than the main file (for example, a header
// file that was included after the preamble), do not show in that case.
if (!AST.getSourceManager().isWrittenInMainFile(FileRange->getBegin()))
sourceLocToPosition(AST.getSourceManager(), FileRange->getBegin()),
sourceLocToPosition(AST.getSourceManager(), FileRange->getEnd())},
Kind, Label.str()});
void addTypeHint(SourceRange R, QualType T, llvm::StringRef Prefix) {
addTypeHint(R, T, Prefix, TypeHintPolicy);
void addTypeHint(SourceRange R, QualType T, llvm::StringRef Prefix,
const PrintingPolicy &Policy) {
// Do not print useless "NULL TYPE" hint.
if (!T.getTypePtrOrNull())
std::string TypeName = T.getAsString(Policy);
if (TypeName.length() < TypeNameLimit)
addInlayHint(R, InlayHintKind::TypeHint, std::string(Prefix) + TypeName);
std::vector<InlayHint> &Results;
ASTContext &AST;
FileID MainFileID;
StringRef MainFileBuf;
const HeuristicResolver *Resolver;
// We want to suppress default template arguments, but otherwise print
// canonical types. Unfortunately, they're conflicting policies so we can't
// have both. For regular types, suppressing template arguments is more
// important, whereas printing canonical types is crucial for structured
// bindings, so we use two separate policies. (See the constructor where
// the policies are initialized for more details.)
PrintingPolicy TypeHintPolicy;
PrintingPolicy StructuredBindingPolicy;
static const size_t TypeNameLimit = 32;
std::vector<InlayHint> inlayHints(ParsedAST &AST) {
std::vector<InlayHint> Results;
InlayHintVisitor Visitor(Results, AST);
// De-duplicate hints. Duplicates can sometimes occur due to e.g. explicit
// template instantiations.
Results.erase(std::unique(Results.begin(), Results.end()), Results.end());
return Results;
} // namespace clangd
} // namespace clang