[clangd] Function return type hints: support lambdas, don't duplicate "->"

[sammccall]

Summary

While here, fix an ugliness:

auto foo()->auto { return 42; }

This (silly) code gains a "-> int" hint. While correct and useful, it renders as

auto foo()->int->auto { return 42; }

which is confusing enough to do more harm than good I think.

[nridge]

Nice!

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

539

Maybe add a comment like "use digraphs to place a literal ] in an annotation range"

[Trass3r]

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

626

Should there be a test for void too or does it just work?

[sammccall]

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

626

Added a test verifying that an auto-typed function/lambda with no return statements gets a -> void hint.

clang-tools-extra/clangd/InlayHints.cpp

bool VisitCallExpr(CallExpr *E) {
     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(),
-                    /*Prefix=*/"-> ");
-      }
-    }
+    if (auto *FPT =
+            llvm::dyn_cast<FunctionProtoType>(D->getType().getTypePtr())) {
+      if (!FPT->hasTrailingReturn())
+        addReturnTypeHint(D, D->getFunctionTypeLoc().getRParenLoc());
+    return true;
 
+  bool VisitLambdaExpr(LambdaExpr *E) {
+    FunctionDecl *D = E->getCallOperator();
+    if (!E->hasExplicitResultType())
+      addReturnTypeHint(D, E->hasExplicitParameters()
+                               ? D->getFunctionTypeLoc().getRParenLoc()
+                               : E->getIntroducerRange().getEnd());
     return true;
   }
 
+  void addReturnTypeHint(FunctionDecl *D, SourceLocation Loc) {
+    auto *AT = D->getReturnType()->getContainedAutoType();
+    if (!AT || AT->getDeducedType().isNull())
+      return;
+    addTypeHint(Loc, D->getReturnType(), /*Prefix=*/"-> ");
+  }
+
   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(), /*Prefix=*/": ",
                     StructuredBindingPolicy);
       }

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

 }
 
 TEST(TypeHints, Lambda) {
   // Do not print something overly verbose like the lambda's location.
   // Show hints for init-captures (but not regular captures).
   assertTypeHints(R"cpp(
     void f() {
       int cap = 42;
-      auto $L[[L]] = [cap, $init[[init]] = 1 + 1](int a) { 
+      auto $L[[L]] = [cap, $init[[init]] = 1 + 1](int a$ret[[)]] { 
         return a + cap + init; 
       };
     }
   )cpp",
                   ExpectedHint{": (lambda)", "L"},
-                  ExpectedHint{": int", "init"});
+                  ExpectedHint{": int", "init"}, ExpectedHint{"-> int", "ret"});
+
+  // Lambda return hint shown even if no param list.
+  assertTypeHints("auto $L[[x]] = <:$ret[[:>]]{return 42;};",
+                  ExpectedHint{": (lambda)", "L"},
+                  ExpectedHint{"-> int", "ret"});
 }
 
 // Structured bindings tests.
 // Note, we hint the individual bindings, not the aggregate.
 
 TEST(TypeHints, StructuredBindings_PublicStruct) {
   assertTypeHints(R"cpp(
     // Struct with public fields.
assertTypeHints(
 
     // Include pointer operators in hint
     int s;
     auto& f2($ret2[[)]] { return s; }
 
     // Do not hint `auto` for trailing return type.
     auto f3() -> int;
 
+    // Do not hint when a trailing return type is specified.
+    auto f4() -> auto* { return "foo"; }
+
     // `auto` conversion operator
     struct A {
       operator auto($retConv[[)]] { return 42; }
     };
 
     // FIXME: Dependent types do not work yet.
     template <typename T>
     struct S {