[clangd] Type hints for C++14 return type deduction

[sammccall]

clang-tools-extra/clangd/InlayHints.cpp

79

nit: bool TrailingReturnType = D->getReturnTypeSourceRange().isValid()?

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

505

This reads as "auto[: int] f1(int x);", which doesn't look much like familiar syntax, C++ or otherwise.

I guess we could try auto f1(int x)[-> int];?

(From playing with these in vscode, I'm not sure I find the punctuation very useful)

[nridge]

clang-tools-extra/clangd/InlayHints.cpp

79

Sorry, I don't really understand this comment.

If you're thinking about the test case where a trailing return type is present and we avoid producing a hint in that case (f3 in TypeHints.ReturnTypeDeduction), that happens because getContainedAutoType() returns null, so we don't get into this block at all.

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

505

I like this suggestion, thanks!

I agree it's nice if the hint is in a place where it would have been valid syntax.

[nridge]

Put hint in trailing return type position

clang-tools-extra/clangd/InlayHints.cpp

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()) {
+        addInlayHint(D->getFunctionTypeLoc().getRParenLoc(),
+                     InlayHintKind::TypeHint,
+                     "-> " + D->getReturnType().getAsString(TypeHintPolicy));
+      }
+    }
+
+    return true;
+  }
+
   bool VisitVarDecl(VarDecl *D) {
     // Do not show hints for the aggregate in a structured binding.
     // In the future, we may show hints for the individual bindings.
     if (isa<DecompositionDecl>(D))
       return true;
 
     if (D->getType()->getContainedAutoType()) {
       if (!D->getType()->isDependentType()) {

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

struct Point {
       int y;
     };
     Point foo();
     auto [x, y] = foo();
   )cpp");
 }
 
 TEST(TypeHints, ReturnTypeDeduction) {
-  // FIXME: Not handled yet.
-  // This test is currently here mostly because a naive implementation
-  // might have us print something not super helpful like the function type.
-  assertTypeHints(R"cpp(
-    auto func(int x) {
-      return x + 1;
-    }
-  )cpp");
+  assertTypeHints(
+      R"cpp(
+    auto f1(int x$ret1a[[)]];  // Hint forward declaration too
+    auto f1(int x$ret1b[[)]] { return x + 1; }
+
+    // Include pointer operators in hint
+    int s;
+    auto& f2($ret2[[)]] { return s; }
+
+    // Do not hint `auto` for trailing return type.
+    auto f3() -> int;
+
+    // `auto` conversion operator
+    struct A {
+      operator auto($retConv[[)]] { return 42; }
+    };
+
+    // FIXME: Dependent types do not work yet.
+    template <typename T>
+    struct S {
+      auto method() { return T(); }
+    };
+  )cpp",
+      ExpectedHint{"-> int", "ret1a"}, ExpectedHint{"-> int", "ret1b"},
+      ExpectedHint{"-> int &", "ret2"}, ExpectedHint{"-> int", "retConv"});
 }
 
 TEST(TypeHints, DependentType) {
   assertTypeHints(R"cpp(
     template <typename T>
     void foo(T arg) {
       // The hint would just be "auto" and we can't do any better.
       auto var1 = arg.method();

 //  - auto x = llvm::dyn_cast<LongTypeName>(y);  // and similar
 //  - stdlib algos return unwieldy __normal_iterator<X*, ...> type
 //    (For this one, perhaps we should omit type hints that start
 //     with a double underscore.)
 
 } // namespace
 } // namespace clangd
 } // namespace clang
 No newline at end of file