[clangd] Add inlay hints for auto-typed parameters with one instantiation.

[sammccall]

Summary

This takes a similar approach as b9b6938183e, and shares some code.
The code sharing is limited as inlay hints wants to deduce the type of the
variable rather than the type of the auto per-se.

It drops support (in both places) for multiple instantiations yielding the same
type, as this is pretty rare and hard to build a nice API around.

[Trass3r]

Looks like this only covers a subset.
I see hints for some generic lambdas but not for others while hovering over auto reveals the type.

[sammccall]

Thanks - any chance you can reduce an example where hover works and inlay hints do not?

[Trass3r]

No apparent differences. Is there a way to automatically reduce it?

[sammccall]

I don't know a good way to automatically reduce examples, I usually do it by hand.

[nridge]

Thanks, this is a nice extension of D119537.

I don't have a good sense for how common the "multiple instantiations, same type" scenario is; perhaps @Trass3r has an opinion on that.

clang-tools-extra/clangd/AST.cpp

570

Is it possible to extract this into a helper function template?

I'm not a huge fan of using macros like this, as the macro definition is harder to read (e.g. its tokens don't get semantic highlighting) and edit (e.g. completion).

clang-tools-extra/clangd/AST.h

136

Why Optional if TypeLoc can represent a null type loc?

clang-tools-extra/clangd/unittests/ASTTests.cpp

303

leftover or deliberate?

[nridge]

clang-tools-extra/clangd/InlayHints.cpp

336

Here's a test case which slips past these checks:

int waldo(auto... args, auto last);
int x = waldo<int, float>(1, 2.0, 'x');

last incorrectly gets float (rather than char) as a hint

[sammccall]

clang-tools-extra/clangd/AST.cpp

570

Oops, of course.

clang-tools-extra/clangd/AST.h

136

It was to match getContainedAutoParamType, which I guess wanted to be explicit about the fact that we may not find one. But this isn't common, so I've dropped it.

clang-tools-extra/clangd/InlayHints.cpp

336

Ah, good catch! For some reason I had it in my head that a pack had to be at the end. (It can't be deduced though? Weird...)

I made this give up hinting once we see a pack.

Added that test.

[sammccall]

address comments

[Trass3r]

I don't have a good sense for how common the "multiple instantiations, same type" scenario is; perhaps @Trass3r has an opinion on that.

Hmm you said the function needs to be defined in the cpp file, right? Then I guess lambdas are indeed the main use-case. I've seen them getting reused sometimes, though just for generic error callbacks.

[Trass3r]

For a callback like

[](auto) {...}

the inlay hint is displayed after the ).
Which also looks confusingly like a hint for the lambda return type (which isn't implemented yet afaik).

And I've even seen this:

With a lambda in a versioned method like

template <Version V> void Foo<V>::foo()

[sammccall]

In D120258#3338555, @Trass3r wrote:

For a callback like

[](auto) {...}

the inlay hint is displayed after the ).

Good catch, thanks!
I'll just suppress the hint here, ParamVarDecl::getLocation() appears to incorrectly point at the rparen and it's not obvious what we're hinting without a name in any case.

Which also looks confusingly like a hint for the lambda return type (which isn't implemented yet afaik).

It's not, but great idea, and I think easy to implement (-> foo is already shown for auto-typed functions).

And I've even seen this:

With a lambda in a versioned method like

template <Version V> void Foo<V>::foo()

OK, this is scary... this is multiple hints at the same point right?

[sammccall]

In D120258#3340357, @sammccall wrote:

And I've even seen this:

With a lambda in a versioned method like

template <Version V> void Foo<V>::foo()

OK, this is scary... this is multiple hints at the same point right?

I haven't been able to reproduce this.

I tried:

template <int> class Foo { void foo(); };

template <int X>
void Foo<X>::foo() {
    auto m = [this](auto x) {};
    m(42);
}

Foo<0> a;
// Foo<1> b;

And I get no hints at all. (Presumably because we only traverse the primary template of foo, and Foo<X>::foo()::m::operator() is never instantiated, only Foo<0>::foo()::m::operator() is (with int).

[sammccall]

suppress (wrong-location) type hint on unnamed auto-typed params

[Trass3r]

In D120258#3340357, @sammccall wrote:

I'll just suppress the hint here, ParamVarDecl::getLocation() appears to incorrectly point at the rparen and it's not obvious what we're hinting without a name in any case.

I guess (auto : type) would be ok and maybe helpful in some cases.
Though one could also argue it's not so important when you ignore the parameter anyway.

In D120258#3340390, @sammccall wrote:

I haven't been able to reproduce this.

I tried:

template <int> class Foo { void foo(); };

template <int X>
void Foo<X>::foo() {
    auto m = [this](auto x) {};
    m(42);
}

Foo<0> a;
// Foo<1> b;

And I get no hints at all. (Presumably because we only traverse the primary template of foo, and Foo<X>::foo()::m::operator() is never instantiated, only Foo<0>::foo()::m::operator() is (with int).

In my case the lambda gets instantiated with different types depending on the template parameter.
Funny enough they disappear for me too if I change auto to auto&&.

Ah ok explicit instantiation made the difference:

template <typename T>
class Foo
{
    void foo();
};

template <typename T>
void Foo<T>::foo()
{
    auto m = [](auto x) {}; // -> (auto x: short: int)
    m(T(42));
}

Foo<int> a;
Foo<short> b;

template class Foo<int>;
template class Foo<short>;

[sammccall]

(I think this patch is good to go now, ready for a stamp if anyone agrees :-)).

In D120258#3340619, @Trass3r wrote:

Ah ok explicit instantiation made the difference:

Interesting! Looks like we're traversing the bodies of explicitly instantiated templates.
This violates our assumption we're only traversing explicitly written code (here the instantiation is explicit but the bodies are not!)
This feels like a RecursiveASTVisitor bug, but IDK if we'll be able to fix it or need to hack around it.

In any case it's not specific to this change:

template <typename T> void foo() {
  auto x = T{}; // x: short: int
}
template void foo<int>();
template void foo<short>();

[Trass3r]

In D120258#3340717, @sammccall wrote:

(I think this patch is good to go now, ready for a stamp if anyone agrees :-)).

I agree. There's still D120258#3336114 but I don't have the time to reduce it atm.

[nridge]

LGTM, thanks!

[Trass3r]

@sammccall pls merge

clang-tools-extra/clangd/AST.h

 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_AST_H_
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_AST_H_
 
 #include "index/SymbolID.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/NestedNameSpecifier.h"
+#include "clang/AST/TypeLoc.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/MacroInfo.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 class SourceManager;

 // (i.e. vector<T*> rather than vector<type-parameter-0-0 *>.
 QualType declaredType(const TypeDecl *D);
 
 /// Retrieves the deduced type at a given location (auto, decltype).
 /// It will return the underlying type.
 /// If the type is an undeduced auto, returns the type itself.
 llvm::Optional<QualType> getDeducedType(ASTContext &, SourceLocation Loc);
 
+// Find the abbreviated-function-template `auto` within a type, or returns null.
+// Similar to getContainedAutoTypeLoc, but these `auto`s are
+// TemplateTypeParmTypes for implicit TTPs, instead of AutoTypes.
+// Also we don't look very hard, just stripping const, references, pointers.
+// FIXME: handle more type patterns.
+TemplateTypeParmTypeLoc getContainedAutoParamType(TypeLoc TL);
+
+// If TemplatedDecl is the generic body of a template, and the template has
+// exactly one visible instantiation, return the instantiated body.
+NamedDecl *getOnlyInstantiation(NamedDecl *TemplatedDecl);
+
 /// Return attributes attached directly to a node.
 std::vector<const Attr *> getAttributes(const DynTypedNode &);
 
 /// Gets the nested name specifier necessary for spelling \p ND in \p
 /// DestContext, at \p InsertionPoint. It selects the shortest suffix of \p ND
 /// such that it is visible in \p DestContext.
 /// Returns an empty string if no qualification is necessary. For example, if
 /// you want to qualify clang::clangd::bar::foo in clang::clangd::x, this

clang-tools-extra/clangd/AST.cpp

bool VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
     while (DT && !DT->getUnderlyingType().isNull()) {
       DeducedType = DT->getUnderlyingType();
       DT = dyn_cast<DecltypeType>(DeducedType.getTypePtr());
     }
     return true;
   }
 
   // Handle functions/lambdas with `auto` typed parameters.
-  // We'll examine visible specializations and see if they yield a unique type.
+  // We deduce the type if there's exactly one instantiation visible.
   bool VisitParmVarDecl(ParmVarDecl *PVD) {
     if (!PVD->getType()->isDependentType())
       return true;
     // 'auto' here does not name an AutoType, but an implicit template param.
     TemplateTypeParmTypeLoc Auto =
-        findContainedAutoTTPLoc(PVD->getTypeSourceInfo()->getTypeLoc());
+        getContainedAutoParamType(PVD->getTypeSourceInfo()->getTypeLoc());
     if (Auto.isNull() || Auto.getNameLoc() != SearchedLocation)
       return true;
+
     // We expect the TTP to be attached to this function template.
     // Find the template and the param index.
-    auto *FD = llvm::dyn_cast<FunctionDecl>(PVD->getDeclContext());
-    if (!FD)
+    auto *Templated = llvm::dyn_cast<FunctionDecl>(PVD->getDeclContext());
+    if (!Templated)
       return true;
-    auto *FTD = FD->getDescribedFunctionTemplate();
+    auto *FTD = Templated->getDescribedFunctionTemplate();
     if (!FTD)
       return true;
     int ParamIndex = paramIndex(*FTD, *Auto.getDecl());
     if (ParamIndex < 0) {
       assert(false && "auto TTP is not from enclosing function?");
       return true;
     }
 
-    // Now determine the unique type arg among the implicit specializations.
-    const ASTContext &Ctx = PVD->getASTContext();
-    QualType UniqueType;
-    CanQualType CanUniqueType;
-    for (const FunctionDecl *Spec : FTD->specializations()) {
-      // Meaning `auto` is a bit overloaded if the function is specialized.
-      if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
-        return true;
-      // Find the type for this specialization.
-      const auto *Args = Spec->getTemplateSpecializationArgs();
-      if (Args->size() != FTD->getTemplateParameters()->size())
-        continue; // no weird variadic stuff
-      QualType SpecType = Args->get(ParamIndex).getAsType();
-      if (SpecType.isNull())
-        continue;
-
-      // Deduced types need only be *canonically* equal.
-      CanQualType CanSpecType = Ctx.getCanonicalType(SpecType);
-      if (CanUniqueType.isNull()) {
-        CanUniqueType = CanSpecType;
-        UniqueType = SpecType;
-        continue;
-      }
-      if (CanUniqueType != CanSpecType)
-        return true; // deduced type is not unique
-    }
-    DeducedType = UniqueType;
+    // Now find the instantiation and the deduced template type arg.
+    auto *Instantiation =
+        llvm::dyn_cast_or_null<FunctionDecl>(getOnlyInstantiation(Templated));
+    if (!Instantiation)
+    const auto *Args = Instantiation->getTemplateSpecializationArgs();
+      return true; // no weird variadic stuff
+    DeducedType = Args->get(ParamIndex).getAsType();
     return true;
   }
 
-  // Find the abbreviated-function-template `auto` within a type.
-  // Similar to getContainedAutoTypeLoc, but these `auto`s are
-  // TemplateTypeParmTypes for implicit TTPs, instead of AutoTypes.
-  // Also we don't look very hard, just stripping const, references, pointers.
-  // FIXME: handle more types: vector<auto>?
-  static TemplateTypeParmTypeLoc findContainedAutoTTPLoc(TypeLoc TL) {
-    if (auto QTL = TL.getAs<QualifiedTypeLoc>())
-      return findContainedAutoTTPLoc(QTL.getUnqualifiedLoc());
-    if (llvm::isa<PointerType, ReferenceType>(TL.getTypePtr()))
-      return findContainedAutoTTPLoc(TL.getNextTypeLoc());
-    if (auto TTPTL = TL.getAs<TemplateTypeParmTypeLoc>()) {
-      if (TTPTL.getTypePtr()->getDecl()->isImplicit())
-        return TTPTL;
-    }
-    return {};
-  }
-
   static int paramIndex(const TemplateDecl &TD, NamedDecl &Param) {
     unsigned I = 0;
     for (auto *ND : *TD.getTemplateParameters()) {
       if (&Param == ND)
         return I;
       ++I;
     }
     return -1;
if (!Loc.isValid())
     return {};
   DeducedTypeVisitor V(Loc);
   V.TraverseAST(ASTCtx);
   if (V.DeducedType.isNull())
     return llvm::None;
   return V.DeducedType;
 }
 
+TemplateTypeParmTypeLoc getContainedAutoParamType(TypeLoc TL) {
+  if (auto QTL = TL.getAs<QualifiedTypeLoc>())
+    return getContainedAutoParamType(QTL.getUnqualifiedLoc());
+  if (llvm::isa<PointerType, ReferenceType, ParenType>(TL.getTypePtr()))
+    return getContainedAutoParamType(TL.getNextTypeLoc());
+  if (auto FTL = TL.getAs<FunctionTypeLoc>())
+    return getContainedAutoParamType(FTL.getReturnLoc());
+  if (auto TTPTL = TL.getAs<TemplateTypeParmTypeLoc>()) {
+    if (TTPTL.getTypePtr()->getDecl()->isImplicit())
+      return TTPTL;
+  }
+  return {};
+}
+
+template <typename TemplateDeclTy>
+static NamedDecl *getOnlyInstantiationImpl(TemplateDeclTy *TD) {
+  NamedDecl *Only = nullptr;
+  for (auto *Spec : TD->specializations()) {
+    if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
+      continue;
+    if (Only != nullptr)
+      return nullptr;
+    Only = Spec;
+  }
+  return Only;
+}
+
+NamedDecl *getOnlyInstantiation(NamedDecl *TemplatedDecl) {
+  if (TemplateDecl *TD = TemplatedDecl->getDescribedTemplate()) {
+    if (auto *CTD = llvm::dyn_cast<ClassTemplateDecl>(TD))
+      return getOnlyInstantiationImpl(CTD);
+    if (auto *FTD = llvm::dyn_cast<FunctionTemplateDecl>(TD))
+      return getOnlyInstantiationImpl(FTD);
+    if (auto *VTD = llvm::dyn_cast<VarTemplateDecl>(TD))
+      return getOnlyInstantiationImpl(VTD);
+  }
+  return nullptr;
+}
+
 std::vector<const Attr *> getAttributes(const DynTypedNode &N) {
   std::vector<const Attr *> Result;
   if (const auto *TL = N.get<TypeLoc>()) {
     for (AttributedTypeLoc ATL = TL->getAs<AttributedTypeLoc>(); !ATL.isNull();
          ATL = ATL.getModifiedLoc().getAs<AttributedTypeLoc>()) {
       if (const Attr *A = ATL.getAttr())
         Result.push_back(A);
       assert(!ATL.getModifiedLoc().isNull());

clang-tools-extra/clangd/InlayHints.cpp

 //===--- InlayHints.cpp ------------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "InlayHints.h"
+#include "AST.h"
 #include "Config.h"
 #include "HeuristicResolver.h"
 #include "ParsedAST.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/ScopeExit.h"
if (D->getType()->getContainedAutoType()) {
         // 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(), /*Prefix=*/": ");
       }
     }
+
+    // Handle templates like `int foo(auto x)` with exactly one instantiation.
+    if (auto *PVD = llvm::dyn_cast<ParmVarDecl>(D)) {
+      if (D->getIdentifier() && PVD->getType()->isDependentType() &&
+          !getContainedAutoParamType(D->getTypeSourceInfo()->getTypeLoc())
+               .isNull()) {
+        if (auto *IPVD = getOnlyParamInstantiation(PVD))
+          addTypeHint(D->getLocation(), IPVD->getType(), /*Prefix=*/": ");
+      }
+    }
+
     return true;
   }
 
+  ParmVarDecl *getOnlyParamInstantiation(ParmVarDecl *D) {
+    auto *TemplateFunction = llvm::dyn_cast<FunctionDecl>(D->getDeclContext());
+    if (!TemplateFunction)
+      return nullptr;
+    auto *InstantiatedFunction = llvm::dyn_cast_or_null<FunctionDecl>(
+        getOnlyInstantiation(TemplateFunction));
+    if (!InstantiatedFunction)
+      return nullptr;
+
+    unsigned ParamIdx = 0;
+    for (auto *Param : TemplateFunction->parameters()) {
+      // Can't reason about param indexes in the presence of preceding packs.
+      // And if this param is a pack, it may expand to multiple params.
+      if (Param->isParameterPack())
+        return nullptr;
+      if (Param == D)
+        break;
+      ++ParamIdx;
+    }
+    assert(ParamIdx < TemplateFunction->getNumParams() &&
+           "Couldn't find param in list?");
+    assert(ParamIdx < InstantiatedFunction->getNumParams() &&
+           "Instantiated function has fewer (non-pack) parameters?");
+    return InstantiatedFunction->getParamDecl(ParamIdx);
+  }
+
   bool VisitInitListExpr(InitListExpr *Syn) {
     // We receive the syntactic form here (shouldVisitImplicitCode() is false).
     // This is the one we will ultimately attach designators to.
     // It may have subobject initializers inlined without braces. The *semantic*
     // form of the init-list has nested init-lists for these.
     // getDesignators will look at the semantic form to determine the labels.
     assert(Syn->isSyntacticForm() && "RAV should not visit implicit code!");
     if (!Cfg.InlayHints.Designators)

clang-tools-extra/clangd/unittests/ASTTests.cpp

 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 using testing::Contains;
 using testing::Each;
+using testing::IsEmpty;
 
 TEST(GetDeducedType, KwAutoKwDecltypeExpansion) {
   struct Test {
     StringRef AnnotatedCode;
     const char *DeducedType;
   } Tests[] = {
       {"^auto i = 0;", "int"},
       {"^auto f(){ return 1;};", "int"},
const char *DeducedType;
             int m = Generic(Foo{});
           )cpp",
           "struct Foo",
       },
       {
           R"cpp(
             // Generic lambda instantiated twice, matching deduction.
             struct Foo{};
-            using Bar = Foo;
             auto Generic = [](^auto x, auto y) { return 0; };
-            int m = Generic(Bar{}, "one");
+            int m = Generic(Foo{}, "one");
             int n = Generic(Foo{}, 2);
           )cpp",
-          "struct Foo",
+          // No deduction although both instantiations yield the same result :-(
+          nullptr,
       },
       {
           R"cpp(
             // Generic lambda instantiated twice, conflicting deduction.
             struct Foo{};
             auto Generic = [](^auto y) { return 0; };
             int m = Generic("one");
             int n = Generic(2);
for (Position Pos : File.points()) {
       } else {
         ASSERT_TRUE(DeducedType);
         EXPECT_EQ(DeducedType->getAsString(), T.DeducedType);
       }
     }
   }
 }
 
+TEST(ClangdAST, GetOnlyInstantiation) {
+  struct {
+    const char *Code;
+    llvm::StringLiteral NodeType;
+    const char *Name;
+  } Cases[] = {
+      {
+          R"cpp(
+            template <typename> class X {};
+            X<int> x;
+          )cpp",
+          "CXXRecord",
+          "template<> class X<int> {}",
+      },
+      {
+          R"cpp(
+            template <typename T> T X = T{};
+            int y = X<char>;
+          )cpp",
+          "Var",
+          // VarTemplateSpecializationDecl doesn't print as template<>...
+          "char X = char{}",
+      },
+      {
+          R"cpp(
+            template <typename T> int X(T) { return 42; }
+            int y = X("text");
+          )cpp",
+          "Function",
+          "template<> int X<const char *>(const char *)",
+      },
+      {
+          R"cpp(
+            int X(auto *x) { return 42; }
+            int y = X("text");
+          )cpp",
+          "Function",
+          "template<> int X<const char>(const char *x)",
+      },
+  };
+
+  for (const auto &Case : Cases) {
+    SCOPED_TRACE(Case.Code);
+    auto TU = TestTU::withCode(Case.Code);
+    TU.ExtraArgs.push_back("-std=c++20");
+    auto AST = TU.build();
+    PrintingPolicy PP = AST.getASTContext().getPrintingPolicy();
+    PP.TerseOutput = true;
+    std::string Name;
+    if (auto *Result = getOnlyInstantiation(
+            const_cast<NamedDecl *>(&findDecl(AST, [&](const NamedDecl &D) {
+              return D.getDescribedTemplate() != nullptr &&
+                     D.getDeclKindName() == Case.NodeType;
+            })))) {
+      llvm::raw_string_ostream OS(Name);
+      Result->print(OS, PP);
+    }
+
+    if (Case.Name)
+      EXPECT_EQ(Case.Name, Name);
+    else
+      EXPECT_THAT(Name, IsEmpty());
+  }
+}
+
+TEST(ClangdAST, GetContainedAutoParamType) {
+  auto TU = TestTU::withCode(R"cpp(
+    int withAuto(
+       auto a,
+       auto *b,
+       const auto *c,
+       auto &&d,
+       auto *&e,
+       auto (*f)(int)
+    ){};
+
+    int withoutAuto(
+      int a,
+      int *b,
+      const int *c,
+      int &&d,
+      int *&e,
+      int (*f)(int)
+    ){};
+  )cpp");
+  TU.ExtraArgs.push_back("-std=c++20");
+  auto AST = TU.build();
+
+  const auto &WithAuto =
+      llvm::cast<FunctionTemplateDecl>(findDecl(AST, "withAuto"));
+  auto ParamsWithAuto = WithAuto.getTemplatedDecl()->parameters();
+  auto *TemplateParamsWithAuto = WithAuto.getTemplateParameters();
+  ASSERT_EQ(ParamsWithAuto.size(), TemplateParamsWithAuto->size());
+
+  for (unsigned I = 0; I < ParamsWithAuto.size(); ++I) {
+    SCOPED_TRACE(ParamsWithAuto[I]->getNameAsString());
+    auto Loc = getContainedAutoParamType(
+        ParamsWithAuto[I]->getTypeSourceInfo()->getTypeLoc());
+    ASSERT_FALSE(Loc.isNull());
+    EXPECT_EQ(Loc.getTypePtr()->getDecl(), TemplateParamsWithAuto->getParam(I));
+  }
+
+  const auto &WithoutAuto =
+      llvm::cast<FunctionDecl>(findDecl(AST, "withoutAuto"));
+  for (auto *ParamWithoutAuto : WithoutAuto.parameters()) {
+    ASSERT_TRUE(getContainedAutoParamType(
+                    ParamWithoutAuto->getTypeSourceInfo()->getTypeLoc())
+                    .isNull());
+  }
+}
+
 TEST(ClangdAST, GetQualification) {
   // Tries to insert the decl `Foo` into position of each decl named `insert`.
   // This is done to get an appropriate DeclContext for the insertion location.
   // Qualifications are the required nested name specifier to spell `Foo` at the
   // `insert`ion location.
   // VisibleNamespaces are assumed to be visible at every insertion location.
   const struct {
     llvm::StringRef Test;

clang-tools-extra/clangd/unittests/InlayHintTests.cpp

 };
 
 MATCHER_P2(HintMatcher, Expected, Code, llvm::to_string(Expected)) {
   if (arg.label != Expected.Label) {
     *result_listener << "label is " << arg.label;
     return false;
   }
   if (arg.range != Code.range(Expected.RangeName)) {
-    *result_listener << "range is " << arg.label << " but $"
+    *result_listener << "range is " << llvm::to_string(arg.range) << " but $"
                      << Expected.RangeName << " is "
                      << llvm::to_string(Code.range(Expected.RangeName));
     return false;
   }
   return true;
 }
 
 MATCHER_P(labelIs, Label, "") { return arg.label == Label; }
 
 Config noHintsConfig() {
   Config C;
   C.InlayHints.Parameters = false;
   C.InlayHints.DeducedTypes = false;
   C.InlayHints.Designators = false;
   return C;
 }
 
 template <typename... ExpectedHints>
 void assertHints(InlayHintKind Kind, llvm::StringRef AnnotatedSource,
                  ExpectedHints... Expected) {
   Annotations Source(AnnotatedSource);
   TestTU TU = TestTU::withCode(Source.code());
-  TU.ExtraArgs.push_back("-std=c++14");
+  TU.ExtraArgs.push_back("-std=c++20");
   auto AST = TU.build();
 
   EXPECT_THAT(hintsOfKind(AST, Kind),
               ElementsAre(HintMatcher(Expected, Source)...));
   // Sneak in a cross-cutting check that hints are disabled by config.
   // We'll hit an assertion failure if addInlayHint still gets called.
   WithContextValue WithCfg(Config::Key, noHintsConfig());
   EXPECT_THAT(inlayHints(AST, llvm::None), IsEmpty());
void foo() {
       auto $var[[var]] = 42;
     }
     template void foo<int>();
     template void foo<float>();
   )cpp",
                   ExpectedHint{": int", "var"});
 }
 
+TEST(TypeHints, SinglyInstantiatedTemplate) {
+  assertTypeHints(R"cpp(
+    auto $lambda[[x]] = [](auto *$param[[y]], auto) { return 42; };
+    int m = x("foo", 3);
+  )cpp",
+                  ExpectedHint{": (lambda)", "lambda"},
+                  ExpectedHint{": const char *", "param"});
+
+  // No hint for packs, or auto params following packs
+  assertTypeHints(R"cpp(
+    int x(auto $a[[a]], auto... b, auto c) { return 42; }
+    int m = x<void*, char, float>(nullptr, 'c', 2.0, 2);
+  )cpp",
+                  ExpectedHint{": void *", "a"});
+}
+
 TEST(DesignatorHints, Basic) {
   assertDesignatorHints(R"cpp(
     struct S { int x, y, z; };
     S s {$x[[1]], $y[[2+2]]};
 
     int x[] = {$0[[0]], $1[[1]]};
   )cpp",
                         ExpectedHint{".x=", "x"}, ExpectedHint{".y=", "y"},

clang-tools-extra/clangd/unittests/TestTU.cpp

bool VisitNamedDecl(const NamedDecl *ND) {
       if (F(*ND))
         Decls.push_back(ND);
       return true;
     }
   } Visitor;
   Visitor.F = Filter;
   Visitor.TraverseDecl(AST.getASTContext().getTranslationUnitDecl());
   if (Visitor.Decls.size() != 1) {
-    llvm::errs() << Visitor.Decls.size() << " symbols matched.";
+    llvm::errs() << Visitor.Decls.size() << " symbols matched.\n";
     assert(Visitor.Decls.size() == 1);
   }
   return *Visitor.Decls.front();
 }
 
 const NamedDecl &findUnqualifiedDecl(ParsedAST &AST, llvm::StringRef Name) {
   return findDecl(AST, [Name](const NamedDecl &ND) {
     if (auto *ID = ND.getIdentifier())
       if (ID->getName() == Name)
         return true;
     return false;
   });
 }
 
 } // namespace clangd
 } // namespace clang