[clangd] Fix an assertion failure in TargetFinder's heuristic resolution of dependent type.

[hokein]

Summary

The assertion is not true anymore after D82739, this patch just removes
it, and rename related functions.

And also fixes a missing cases.

[nridge]

Thanks!

clang-tools-extra/clangd/FindTarget.cpp

171

I do think the "heuristic" nature of this function is an important part of its interface that's currently lost with this rename.

However, I think that's fine for now. In a future refactor (to get code-completion to use this machinery as well) I plan to move these functions into a HeuristicResolver class or a heuristics sub-namespace or something like that.

[hokein]

clang-tools-extra/clangd/FindTarget.cpp

171

yeah, I agree. It would be clearer if these functions are put into a Heuristic context.

clang-tools-extra/clangd/FindTarget.cpp

if (TST->getNumArgs() == 0)
     return nullptr;
   const TemplateArgument &FirstArg = TST->getArg(0);
   if (FirstArg.getKind() != TemplateArgument::Type)
     return nullptr;
   return FirstArg.getAsType().getTypePtrOrNull();
 }
 
 // Forward declaration, needed as this function is mutually recursive
-// with resolveDependentExprToDecls.
-const Type *resolveDependentExprToType(const Expr *E);
+// with resolveExprToDecls.
+const Type *resolveExprToType(const Expr *E);
 
-// Try to heuristically resolve a dependent expression `E` to one
+// Try to heuristically resolve a possibly-dependent expression `E` to one
 // or more declarations that it likely references.
-std::vector<const NamedDecl *> resolveDependentExprToDecls(const Expr *E) {
-  assert(E->isTypeDependent());
+std::vector<const NamedDecl *> resolveExprToDecls(const Expr *E) {
   if (const auto *ME = dyn_cast<CXXDependentScopeMemberExpr>(E)) {
     const Type *BaseType = ME->getBaseType().getTypePtrOrNull();
     if (ME->isArrow()) {
       BaseType = getPointeeType(BaseType);
     }
     if (!BaseType)
       return {};
     if (const auto *BT = BaseType->getAs<BuiltinType>()) {
       // If BaseType is the type of a dependent expression, it's just
       // represented as BultinType::Dependent which gives us no information. We
       // can get further by analyzing the depedent expression.
       Expr *Base = ME->isImplicitAccess() ? nullptr : ME->getBase();
       if (Base && BT->getKind() == BuiltinType::Dependent) {
-        BaseType = resolveDependentExprToType(Base);
+        BaseType = resolveExprToType(Base);
       }
     }
     return getMembersReferencedViaDependentName(
         BaseType, [ME](ASTContext &) { return ME->getMember(); },
         /*IsNonstaticMember=*/true);
   }
   if (const auto *RE = dyn_cast<DependentScopeDeclRefExpr>(E)) {
     return getMembersReferencedViaDependentName(
         RE->getQualifier()->getAsType(),
         [RE](ASTContext &) { return RE->getDeclName(); },
         /*IsNonstaticMember=*/false);
   }
   if (const auto *CE = dyn_cast<CallExpr>(E)) {
-    const auto *CalleeType = resolveDependentExprToType(CE->getCallee());
+    const auto *CalleeType = resolveExprToType(CE->getCallee());
     if (!CalleeType)
       return {};
     if (const auto *FnTypePtr = CalleeType->getAs<PointerType>())
       CalleeType = FnTypePtr->getPointeeType().getTypePtr();
     if (const FunctionType *FnType = CalleeType->getAs<FunctionType>()) {
       if (const auto *D =
               resolveTypeToRecordDecl(FnType->getReturnType().getTypePtr())) {
         return {D};
       }
     }
   }
-  if (const auto *ME = dyn_cast<MemberExpr>(E)) {
+  if (const auto *ME = dyn_cast<MemberExpr>(E))
     return {ME->getMemberDecl()};
-  }
+  if (const auto *DRE = dyn_cast<DeclRefExpr>(E))
+    return {DRE->getFoundDecl()};
   return {};
 }
 
-// Try to heuristically resolve the type of a dependent expression `E`.
-const Type *resolveDependentExprToType(const Expr *E) {
-  std::vector<const NamedDecl *> Decls = resolveDependentExprToDecls(E);
+// Try to heuristically resolve the type of a possibly-dependent expression `E`.
+const Type *resolveExprToType(const Expr *E) {
+  std::vector<const NamedDecl *> Decls = resolveExprToDecls(E);
   if (Decls.size() != 1) // Names an overload set -- just bail.
     return nullptr;
   if (const auto *TD = dyn_cast<TypeDecl>(Decls[0])) {
     return TD->getTypeForDecl();
   } else if (const auto *VD = dyn_cast<ValueDecl>(Decls[0])) {
     return VD->getType().getTypePtrOrNull();
   }
   return nullptr;
struct Visitor : public ConstStmtVisitor<Visitor> {
           Outer.add(LabelDecl, Flags);
       }
       void VisitLabelStmt(const LabelStmt *Label) {
         if (auto *LabelDecl = Label->getDecl())
           Outer.add(LabelDecl, Flags);
       }
       void
       VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E) {
-        for (const NamedDecl *D : resolveDependentExprToDecls(E)) {
+        for (const NamedDecl *D : resolveExprToDecls(E)) {
           Outer.add(D, Flags);
         }
       }
       void VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *E) {
-        for (const NamedDecl *D : resolveDependentExprToDecls(E)) {
+        for (const NamedDecl *D : resolveExprToDecls(E)) {
           Outer.add(D, Flags);
         }
       }
       void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *OIRE) {
         Outer.add(OIRE->getDecl(), Flags);
       }
       void VisitObjCMessageExpr(const ObjCMessageExpr *OME) {
         Outer.add(OME->getMethodDecl(), Flags);

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

Code = R"cpp(
         template <typename T> struct Foo {
           Bar func(int);
           void test() {
             func(1).[[aaaa]];
           }
         };
       )cpp";
   EXPECT_DECLS("CXXDependentScopeMemberExpr", "int aaaa");
+
+  Code = R"cpp(
+        class Foo {
+        public:
+          static Foo k(int);
+          template <typename T> T convert() const;
+        };
+        template <typename T>
+        void test() {
+          Foo::k(T()).template [[convert]]<T>();
+        }
+      )cpp";
+  EXPECT_DECLS("CXXDependentScopeMemberExpr",
+               "template <typename T> T convert() const");
 }
 
 TEST_F(TargetDeclTest, ObjC) {
   Flags = {"-xobjective-c"};
   Code = R"cpp(
     @interface Foo {}
     -(void)bar;
     @end