[clangd] show underlying type in type hint for `decltype(expr)`

[nridge]

Thanks, I think this behaviour change is reasonable.

clang-tools-extra/clangd/InlayHints.cpp

680

Can we factor out a function ShouldPrintCanonicalType(QualType), and add a comment like this in its implementation:

// The sugared type is more useful in some cases, and the canonical
// type in other cases. For now, prefer the sugared type unless
// we are printing `decltype(expr)`. This could be refined further
// (see https://github.com/clangd/clangd/issues/1298).

Then in this function we can set:

TypeHintPolicy.PrintCanonicalTypes = ShouldPrintCanonicalType(T);

[v1nh1shungry]

apply comment's suggestions

[v1nh1shungry]

Thanks for reviewing and giving suggestions!

[nridge]

Thanks!

clang-tools-extra/clangd/InlayHints.cpp

665

small nit: could you put the comment inside the function, since it's more an explanation of the current logic in the implementation

[v1nh1shungry]

move the comment

clang-tools-extra/clangd/InlayHints.cpp

llvm::Optional<Range> getHintRange(SourceRange R) {
     // Hint must be within the main file, not e.g. a non-preamble include.
     if (SM.getFileID(Spelled->front().location()) != SM.getMainFileID() ||
         SM.getFileID(Spelled->back().location()) != SM.getMainFileID())
       return std::nullopt;
     return Range{sourceLocToPosition(SM, Spelled->front().location()),
                  sourceLocToPosition(SM, Spelled->back().endLocation())};
   }
 
+  static bool shouldPrintCanonicalType(QualType QT) {
+    // The sugared type is more useful in some cases, and the canonical
+    // type in other cases. For now, prefer the sugared type unless
+    // we are printing `decltype(expr)`. This could be refined further
+    // (see https://github.com/clangd/clangd/issues/1298).
+    if (QT->isDecltypeType())
+      return true;
+    if (const AutoType *AT = QT->getContainedAutoType())
+      if (AT->getDeducedType()->isDecltypeType())
+        return true;
+    return false;
+  }
+
   void addTypeHint(SourceRange R, QualType T, llvm::StringRef Prefix) {
+    TypeHintPolicy.PrintCanonicalTypes = shouldPrintCanonicalType(T);
     addTypeHint(R, T, Prefix, TypeHintPolicy);
   }
 
   void addTypeHint(SourceRange R, QualType T, llvm::StringRef Prefix,
                    const PrintingPolicy &Policy) {
     if (!Cfg.InlayHints.DeducedTypes || T.isNull())
       return;
 
     std::string TypeName = T.getAsString(Policy);

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

TEST(TypeHints, Aliased) {
   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>;
+
+    auto $h[[h]] = $i[[decltype(0)]]{};
   )cpp",
-                  ExpectedHint{": int", "a"},
-                  ExpectedHint{": decltype(0)", "b"},
+                  ExpectedHint{": int", "a"}, ExpectedHint{": int", "b"},
                   ExpectedHint{": int", "c"}, ExpectedHint{": int", "e"},
-                  ExpectedHint{": int", "f"}, ExpectedHint{": int", "g"});
+                  ExpectedHint{": int", "f"}, ExpectedHint{": int", "g"},
+                  ExpectedHint{": int", "h"}, ExpectedHint{": int", "i"});
 }
 
 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]]};