[clangd] Support hover on "aut^o *".

[kadircet]

LGTM, thanks!

clangd/XRefs.cpp

class DeducedTypeVisitor : public RecursiveASTVisitor<DeducedTypeVisitor> {
   llvm::Optional<QualType> DeducedType;
 
 public:
   DeducedTypeVisitor(SourceLocation SearchedLocation)
       : SearchedLocation(SearchedLocation) {}
 
   llvm::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 = D->getType();
-    // "auto &" is represented as a ReferenceType containing an AutoType
-    if (const ReferenceType *RT = dyn_cast<ReferenceType>(DeclT.getTypePtr()))
-      DeclT = RT->getPointeeType();
-
+    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
bool VisitFunctionDecl(FunctionDecl *D) {
     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 = D->getReturnType();
-    // "auto &" is represented as a ReferenceType containing an AutoType.
-    if (const ReferenceType *RT = dyn_cast<ReferenceType>(T.getTypePtr()))
-      T = RT->getPointeeType();
-
+    auto T = UnwrapReferenceOrPointer(D->getReturnType());
     const AutoType *AT = dyn_cast<AutoType>(T.getTypePtr());
     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());
       if (!DT->getUnderlyingType().isNull())
         DeducedType = DT->getUnderlyingType();
     }

unittests/clangd/XRefsTests.cpp

OneTest Tests[] = {
           R"cpp(// Simple initialization with auto&
             void foo() {
               ^auto& i = 1;
             }
           )cpp",
           "int",
       },
       {
+          R"cpp(// Simple initialization with auto*
+            void foo() {
+              int a = 1;
+              ^auto* i = &a;
+            }
+          )cpp",
+          "int",
+      },
+      {
           R"cpp(// Auto with initializer list.
             namespace std
             {
               template<class _E>
               class initializer_list {};
             }
             void foo() {
               ^auto i = {1,2};
OneTest Tests[] = {
             struct Bar {};
             ^auto& test() {
               return Bar();
             }
           )cpp",
           "struct Bar",
       },
       {
+          R"cpp(// auto* in function return
+            struct Bar {};
+            ^auto* test() {
+              Bar* bar;
+              return bar;
+            }
+          )cpp",
+          "struct Bar",
+      },
+      {
           R"cpp(// const auto& in function return
             struct Bar {};
             const ^auto& test() {
               return Bar();
             }
           )cpp",
           "struct Bar",
       },