[clangd] Support type hints for `decltype(expr)`

[Trass3r]

clang-tools-extra/clangd/InlayHints.cpp

329

Should use dyn_cast instead of is+cast I think.

[v1nh1shungry]

Apply the comment's suggestion

[v1nh1shungry]

@Trass3r Thank you for the suggestion!

[v1nh1shungry]

Avoid type hints for dependent types

[v1nh1shungry]

• fix qualifiers
• fix recursive decltype (partly)
• support return type

[nridge]

Sorry for being a slow reviewer.

I think showing type hints for decltype(expr) would be a nice enhancement. @v1nh1shungry, are you interested in working further on this?

One high-level thought I had is: what if we attached the type hint to the closing ) of the decltype (and had it pertain only to the decltype(expr), not anything surrounding it like const or &)? It seems to me that this would both simplify the implementation, and allow us to show hints in places where decltype is used in a context unrelated to a variable or function declaration (for example, in something like using Foo = A<B<decltype(expr), C>, D>, if decltype(expr) was int, we would show using Foo = A<B<decltype(expr) : int, C>, D>. What do you think about this approach?

[v1nh1shungry]

Thanks for the feedback!

One high-level thought I had is: what if we attached the type hint to the closing ) of the decltype (and had it pertain only to the decltype(expr), not anything surrounding it like const or &)? It seems to me that this would both simplify the implementation, and allow us to show hints in places where decltype is used in a context unrelated to a variable or function declaration (for example, in something like using Foo = A<B<decltype(expr), C>, D>, if decltype(expr) was int, we would show using Foo = A<B<decltype(expr) : int, C>, D>. What do you think about this approach?

I think this approach is better.

I think showing type hints for decltype(expr) would be a nice enhancement. @v1nh1shungry, are you interested in working further on this?

Sure!

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

1155

The only concern I have is how to deal with this situation.

When I wrote this patch I thought maybe I could remove the & and figure out the underlying type of decltype(0) recursively and then add the & back. But at that time I couldn't find a way to get the referenced type or the pointee type.

[nridge]

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

1155

This is a problem we already have for auto. For example, if you write:

auto i = decltype(0)();

the type hint for the auto is decltype(0).

The reason is that we are printing the type with TypeHintPolicy, which has PrintCanonicalTypes=false (the default). This means the type is printed without "type sugar" (e.g. decltype, typedefs) being replaced with their "underlying type".

We could alternatively print it with PrintCanonicalTypes=true, which would make the hint given in this case better, but it would make other cases worse (e.g. replacing std::string with std::basic_string<...>).

For the purposes of this patch, I think it's fine to just live with whatever type is printed with the current printing policy.

If we want to make improvements in this area, we can do that in a separate patch, and in a way that affects both auto and decltype(expr).

[v1nh1shungry]

Got it! Thank you for the detailed explanation!

[v1nh1shungry]

reimplement and address review's suggestions

[nridge]

Thanks!

[v1nh1shungry]

@nridge Thank you for reviewing!

If this patch is ready to land, could you please help me commit it? Thanks again!

[nridge]

Done, thanks for the patch!

clang-tools-extra/clangd/InlayHints.cpp

bool VisitLambdaExpr(LambdaExpr *E) {
     if (!E->hasExplicitResultType())
       addReturnTypeHint(D, E->hasExplicitParameters()
                                ? D->getFunctionTypeLoc().getRParenLoc()
                                : E->getIntroducerRange().getEnd());
     return true;
   }
 
   void addReturnTypeHint(FunctionDecl *D, SourceRange Range) {
-    auto *AT = D->getReturnType()->getContainedAutoType();
-    if (!AT || AT->getDeducedType().isNull())
-      return;
-    addTypeHint(Range, D->getReturnType(), /*Prefix=*/"-> ");
+    auto RT = D->getReturnType();
+
+    if (auto *AT = RT->getContainedAutoType();
+        AT && !AT->getDeducedType().isNull())
+      addTypeHint(Range, RT, /*Prefix=*/"-> ");
+
+    if (llvm::isa<DecltypeType>(RT))
+      if (auto UT = getUnderlyingType(RT); !UT->isDependentType())
+        addTypeHint(Range, UT, /*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);
       }
       return true;
     }
 
-    if (D->getType()->getContainedAutoType()) {
-      if (!D->getType()->isDependentType()) {
+    auto T = D->getType();
+
+    // Show type hint for `decltype(expr)`, e.g.
+    // for `decltype(0) i;`, show `decltype(0) i: int;`
+    if (llvm::isa<DecltypeType>(T)) {
+      if (auto UT = getUnderlyingType(T); !UT->isDependentType())
+        addTypeHint(D->getLocation(), UT, /*Prefix=*/": ");
+      return true;
+    }
+
+    if (T->getContainedAutoType()) {
+      if (!T->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(), /*Prefix=*/": ");
+        addTypeHint(D->getLocation(), T, /*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;
   }
 
bool VisitInitListExpr(InitListExpr *Syn) {
     return true;
   }
 
   // FIXME: Handle RecoveryExpr to try to hint some invalid calls.
 
 private:
   using NameVec = SmallVector<StringRef, 8>;
 
+  static QualType getUnderlyingType(QualType T) {
+    auto LFQ = T.getLocalFastQualifiers();
+    while (const auto *DT = dyn_cast<DecltypeType>(T))
+      T = DT->getUnderlyingType();
+    T.setLocalFastQualifiers(LFQ);
+    return T;
+  }
+
   void processCall(const FunctionDecl *Callee,
                    llvm::ArrayRef<const Expr *> Args) {
     if (!Cfg.InlayHints.Parameters || Args.size() == 0 || !Callee)
       return;
 
     // The parameter name of a move or copy constructor is not very interesting.
     if (auto *Ctor = dyn_cast<CXXConstructorDecl>(Callee))
       if (Ctor->isCopyOrMoveConstructor())

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

TEST(TypeHints, DecltypeAuto) {
   assertTypeHints(R"cpp(
     int x = 42;
     int& y = x;
     decltype(auto) $z[[z]] = y;
   )cpp",
                   ExpectedHint{": int &", "z"});
 }
 
+TEST(TypeHints, Decltype) {
+  assertTypeHints(R"cpp(
+    decltype(0) $a[[a]];
+    decltype(a) $b[[b]];
+    const decltype(0) $c[[c]] = 0;
+  )cpp",
+                  ExpectedHint{": int", "a"}, ExpectedHint{": int", "b"},
+                  ExpectedHint{": const int", "c"});
+  assertTypeHints(R"cpp(
+    decltype(0) $i[[i]] = 0;
+    // FIXME: Nice to show `: int &`
+    decltype((i)) $a[[a]] = i;
+  )cpp",
+                  ExpectedHint{": int", "i"},
+                  ExpectedHint{": decltype(0) &", "a"});
+  // FIXME: Support type hints for l/r reference
+  assertTypeHints(R"cpp(
+    int i = 0;
+    decltype(0) &$a[[a]] = i;
+    decltype(0) &&$b[[b]] = 0;
+  )cpp");
+}
+
 TEST(TypeHints, NoQualifiers) {
   assertTypeHints(R"cpp(
     namespace A {
       namespace B {
         struct S1 {};
         S1 foo();
         auto $x[[x]] = foo();
 
assertTypeHints(
     // 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 f5($noreturn[[)]] {}
 
+    decltype(0) f6($ret3[[)]];
+
     // `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{"-> void", "noreturn"},
-      ExpectedHint{"-> int", "retConv"});
+      ExpectedHint{"-> int", "ret3"}, 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();