[clangd] Rename HeuristicResolver::resolveCallExpr() to resolveReturnTypeOfCallExpr()

[nridge]

The motivation for this patch is that the old name initially confused me into thinking it resolved the callee decl of the call-expr.

[sammccall]

Agree this is confusing, thanks for fixing!

clang-tools-extra/clangd/HeuristicResolver.h

57

nit: I think resolveTypeOfCallExpr (or resolveCallExprType) is sufficient/better, as technically it's the callee that has a return type, the call expr just has a type

[nridge]

Address review comment

clang-tools-extra/clangd/HeuristicResolver.h

public:
   HeuristicResolver(ASTContext &Ctx) : Ctx(Ctx) {}
 
   // Try to heuristically resolve certain types of expressions, declarations, or
   // types to one or more likely-referenced declarations.
   std::vector<const NamedDecl *>
   resolveMemberExpr(const CXXDependentScopeMemberExpr *ME) const;
   std::vector<const NamedDecl *>
   resolveDeclRefExpr(const DependentScopeDeclRefExpr *RE) const;
-  std::vector<const NamedDecl *> resolveCallExpr(const CallExpr *CE) const;
+  std::vector<const NamedDecl *>
+  resolveTypeOfCallExpr(const CallExpr *CE) const;
   std::vector<const NamedDecl *>
   resolveUsingValueDecl(const UnresolvedUsingValueDecl *UUVD) const;
   std::vector<const NamedDecl *>
   resolveDependentNameType(const DependentNameType *DNT) const;
   std::vector<const NamedDecl *> resolveTemplateSpecializationType(
       const DependentTemplateSpecializationType *DTST) const;
 
   // Try to heuristically resolve a dependent nested name specifier

clang-tools-extra/clangd/HeuristicResolver.cpp

 
 std::vector<const NamedDecl *> HeuristicResolver::resolveDeclRefExpr(
     const DependentScopeDeclRefExpr *RE) const {
   return resolveDependentMember(RE->getQualifier()->getAsType(),
                                 RE->getDeclName(), StaticFilter);
 }
 
 std::vector<const NamedDecl *>
-HeuristicResolver::resolveCallExpr(const CallExpr *CE) const {
+HeuristicResolver::resolveTypeOfCallExpr(const CallExpr *CE) const {
   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())) {

 const Type *HeuristicResolver::resolveExprToType(const Expr *E) const {
   if (const auto *ME = dyn_cast<CXXDependentScopeMemberExpr>(E)) {
     return resolveDeclsToType(resolveMemberExpr(ME));
   }
   if (const auto *RE = dyn_cast<DependentScopeDeclRefExpr>(E)) {
     return resolveDeclsToType(resolveDeclRefExpr(RE));
   }
   if (const auto *CE = dyn_cast<CallExpr>(E)) {
-    return resolveDeclsToType(resolveCallExpr(CE));
+    return resolveDeclsToType(resolveTypeOfCallExpr(CE));
   }
   if (const auto *ME = dyn_cast<MemberExpr>(E))
     return resolveDeclsToType({ME->getMemberDecl()});
 
   return E->getType().getTypePtr();
 }
 
 const Type *HeuristicResolver::resolveNestedNameSpecifierToType(
if (auto *RD = resolveTypeToRecordDecl(T)) {
     RD = RD->getDefinition();
     return RD->lookupDependentName(Name, Filter);
   }
   return {};
 }
 
 } // namespace clangd
 } // namespace clang
 No newline at end of file