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

[Trass3r]

clang-tools-extra/clangd/InlayHints.cpp

321

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

InlayHintVisitor(std::vector<InlayHint> &Results, ParsedAST &AST,
     // 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 VisitTypeLoc(TypeLoc TL) {
+    if (const auto *DT = llvm::dyn_cast<DecltypeType>(TL.getType()))
+      if (QualType UT = DT->getUnderlyingType(); !UT->isDependentType())
+        addTypeHint(TL.getSourceRange(), UT, ": ");
+    return 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;
if (D->getType()->getContainedAutoType()) {
         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;
   }
 

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

namespace A {
       namespace B {
         struct S1 {};
         S1 foo();
         auto $x[[x]] = foo();
 
         struct S2 {
           template <typename T>
           struct Inner {};
         };
         S2::Inner<int> bar();
         auto $y[[y]] = bar();
       }
     }
   )cpp",
                   ExpectedHint{": S1", "x"},
                   // FIXME: We want to suppress scope specifiers
                   //        here because we are into the whole
TEST(TypeHints, Aliased) {
   // https://github.com/clangd/clangd/issues/1140
   TestTU TU = TestTU::withCode("void foo(void){} extern typeof(foo) foo;");
   TU.ExtraArgs.push_back("-xc");
   auto AST = TU.build();
 
   EXPECT_THAT(hintsOfKind(AST, InlayHintKind::Type), IsEmpty());
 }
 
+TEST(TypeHints, Decltype) {
+  assertTypeHints(R"cpp(
+    $a[[decltype(0)]] a;
+    // FIXME: will be nice to show `: int` instead
+    $b[[decltype(a)]] b;
+    const $c[[decltype(0)]] &c = b;
+
+    // Don't show for dependent type
+    template <class T>
+    constexpr decltype(T{}) d;
+
+    $e[[decltype(0)]] e();
+    auto f() -> $f[[decltype(0)]];
+
+    template <class, class> struct Foo;
+    using G = Foo<$g[[decltype(0)]], float>;
+  )cpp",
+                  ExpectedHint{": int", "a"},
+                  ExpectedHint{": decltype(0)", "b"},
+                  ExpectedHint{": int", "c"}, ExpectedHint{": int", "e"},
+                  ExpectedHint{": int", "f"}, ExpectedHint{": int", "g"});
+}
+
 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"},