[clangd] Simplify auto hover

[ilya-biryukov]

Summary

Use helper from clang. Also fixes some weird corner cases, e.g.

auto (*foo)() = bar;

[kadircet]

LGTM, it bugs me that some part in the documentation says it doesn't go through decltype(This looks through declarators like pointer types, but not through decltype or typedefs) but since tests containing decltype didn't break it looks OK to me. I would still wait for @hokein to have another look as well.

[hokein]

looks good! didn't know this API before.

clangd/XRefs.cpp

592 ↗

(On Diff #169917)

Maybe just

if (auto* DT = D->getType()->getContainedDeducedType())
   DeducedType = *DT;

?

620 ↗

(On Diff #169917)

also expand this comment mentioning that decltype is not handled by the getContainedAutoType or getContainedDeducedType?

[ilya-biryukov]

• Addressed review comments

[ilya-biryukov]

In D53347#1267216, @kadircet wrote:

LGTM, it bugs me that some part in the documentation says it doesn't go through decltype(This looks through declarators like pointer types, but not through decltype or typedefs) but since tests containing decltype didn't break it looks OK to me. I would still wait for @hokein to have another look as well.

The decltypes are handled separately in VisitDecltypeTypeLoc and typedefs are a decl, so they are handled even before the visitor runs. This is only about 'auto'. So I think we're covered here.

clangd/XRefs.cpp

592 ↗

(On Diff #169917)

It feels like explicitly unwrapping auto from the deduced type instead of relying the printer to do that is a bit more straightforward.

Simplified code a bit per suggestions.

clang-tools-extra/trunk/clangd/XRefs.cpp

class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
   Optional<QualType> DeducedType;
 
 public:
   DeducedTypeVisitor(SourceLocation SearchedLocation)
       : SearchedLocation(SearchedLocation) {}
 
   Optional<QualType> getDeducedType() { return DeducedType; }
 
-  // Remove the surrounding Reference or Pointer type of the given type T.
-  QualType UnwrapReferenceOrPointer(QualType T) {
-    // "auto &" is represented as a ReferenceType containing an AutoType
-    if (const ReferenceType *RT = dyn_cast<ReferenceType>(T.getTypePtr()))
-      return RT->getPointeeType();
-    // "auto *" is represented as a PointerType containing an AutoType
-    if (const PointerType *PT = dyn_cast<PointerType>(T.getTypePtr()))
-      return PT->getPointeeType();
-    return T;
-  }
-
   // Handle auto initializers:
   //- auto i = 1;
   //- decltype(auto) i = 1;
   //- auto& i = 1;
   //- auto* i = &a;
   bool VisitDeclaratorDecl(DeclaratorDecl *D) {
     if (!D->getTypeSourceInfo() ||
         D->getTypeSourceInfo()->getTypeLoc().getBeginLoc() != SearchedLocation)
       return true;
 
-    auto DeclT = UnwrapReferenceOrPointer(D->getType());
-    const AutoType *AT = dyn_cast<AutoType>(DeclT.getTypePtr());
-    if (AT && !AT->getDeducedType().isNull()) {
-      // For auto, use the underlying type because the const& would be
-      // represented twice: written in the code and in the hover.
-      // Example: "const auto I = 1", we only want "int" when hovering on auto,
-      // not "const int".
-      //
-      // For decltype(auto), take the type as is because it cannot be written
-      // with qualifiers or references but its decuded type can be const-ref.
-      DeducedType = AT->isDecltypeAuto() ? DeclT : DeclT.getUnqualifiedType();
+    if (auto *AT = D->getType()->getContainedAutoType()) {
+      if (!AT->getDeducedType().isNull())
+        DeducedType = AT->getDeducedType();
     }
     return true;
   }
 
   // Handle auto return types:
   //- auto foo() {}
   //- auto& foo() {}
   //- auto foo() -> decltype(1+1) {}
   //- operator auto() const { return 10; }
   bool VisitFunctionDecl(FunctionDecl *D) {
     if (!D->getTypeSourceInfo())
       return true;
     // Loc of auto in return type (c++14).
     auto CurLoc = D->getReturnTypeSourceRange().getBegin();
     // Loc of "auto" in operator auto()
     if (CurLoc.isInvalid() && dyn_cast<CXXConversionDecl>(D))
       CurLoc = D->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
     // Loc of "auto" in function with traling return type (c++11).
     if (CurLoc.isInvalid())
       CurLoc = D->getSourceRange().getBegin();
     if (CurLoc != SearchedLocation)
       return true;
 
-    auto T = UnwrapReferenceOrPointer(D->getReturnType());
-    const AutoType *AT = dyn_cast<AutoType>(T.getTypePtr());
+    const AutoType *AT = D->getReturnType()->getContainedAutoType();
     if (AT && !AT->getDeducedType().isNull()) {
-      DeducedType = T.getUnqualifiedType();
-    } else { // auto in a trailing return type just points to a DecltypeType.
-      const DecltypeType *DT = dyn_cast<DecltypeType>(T.getTypePtr());
+      DeducedType = AT->getDeducedType();
+    } else {
+      // auto in a trailing return type just points to a DecltypeType and
+      // getContainedAutoType does not unwrap it.
+      const DecltypeType *DT = dyn_cast<DecltypeType>(D->getReturnType());
       if (!DT->getUnderlyingType().isNull())
         DeducedType = DT->getUnderlyingType();
     }
     return true;
   }
 
   // Handle non-auto decltype, e.g.:
   // - auto foo() -> decltype(expr) {}

clang-tools-extra/trunk/unittests/clangd/XRefsTests.cpp

OneTest Tests[] = {
             void func() {
             }
             void foo() {
                func<1>();
             }
           )cpp",
           "",
       },
+      {
+          R"cpp(// More compilcated structured types.
+            int bar();
+            ^auto (*foo)() = bar;
+          )cpp",
+          "int",
+      },
   };
 
   for (const OneTest &Test : Tests) {
     Annotations T(Test.Input);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     auto AST = TU.build();
     if (auto H = getHover(AST, T.point())) {