[clang] Heuristic resolution for explicit object parameter

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

@@ -17,10 +17,11 @@
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
-#include <algorithm>
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
+#include <algorithm>
+
 namespace clang {
 namespace clangd {
 namespace {
@@ -861,13 +862,33 @@ TEST(RenameTest, WithinFileRename) {
 
         void func([[Fo^o]] *f) {}
       )cpp",
+
+      // rename with explicit object parameter
+      R"cpp(
+      struct Foo {
+        int [[memb^er]] {};
+        auto&& getter1(this auto&& self) {
+          auto local = [&] {
+            return self.[[memb^er]];
+          }();
+          return local + self.[[memb^er]];
+        }
+        auto&& getter2(this Foo&& self) {
+          return self.[[memb^er]];
+        }
+        int normal() {
+          return this->[[mem^ber]] + [[memb^er]];
+        }
+      };
+    )cpp",
   };
   llvm::StringRef NewName = "NewName";
   for (llvm::StringRef T : Tests) {
     SCOPED_TRACE(T);
     Annotations Code(T);
     auto TU = TestTU::withCode(Code.code());
     TU.ExtraArgs.push_back("-xobjective-c++");
+    TU.ExtraArgs.push_back("-std=c++23");
     auto AST = TU.build();
     auto Index = TU.index();
     for (const auto &RenamePos : Code.points()) {
@@ -2467,7 +2488,6 @@ TEST(CrossFileRenameTests, adjustmentCost) {
               T.ExpectedCost);
   }
 }
-
 } // namespace
 } // namespace clangd
 } // namespace clang

clang/lib/Sema/HeuristicResolver.cpp

@@ -14,6 +14,7 @@
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "llvm/ADT/identity.h"
+#include <optional>
 
 namespace clang {
 
@@ -255,6 +256,21 @@ QualType HeuristicResolverImpl::simplifyType(QualType Type, const Expr *E,
         }
       }
     }
+    // check if member expr is in the context of an explicit object method
+    if (!T.Type.isNull() &&
+        (T.Type->isUndeducedAutoType() || T.Type->isTemplateTypeParmType())) {
+      if (auto *DRE = dyn_cast_if_present<DeclRefExpr>(T.E)) {
+        auto *PrDecl = dyn_cast_if_present<ParmVarDecl>(DRE->getDecl());
+        // Then the type of 'this' should be type of the record the method is
+        // defined in
+        if (PrDecl && PrDecl->isExplicitObjectParameter()) {
+          const auto *Parent =
+              dyn_cast<TypeDecl>(PrDecl->getDeclContext()->getParent());
+          return {Ctx.getTypeDeclType(Parent)};
+        }
+      }
+    }
+
     return T;
   };
   // As an additional protection against infinite loops, bound the number of
@@ -305,6 +321,14 @@ std::vector<const NamedDecl *> HeuristicResolverImpl::resolveMemberExpr(
   Expr *Base = ME->isImplicitAccess() ? nullptr : ME->getBase();
   QualType BaseType = ME->getBaseType();
   BaseType = simplifyType(BaseType, Base, ME->isArrow());
+
+  // fflush(stdout);
+  // fflush(stderr);
+  // std::flush(std::cout);
+  // std::flush(std::cerr);
+  // using namespace std::chrono_literals;
+  // std::this_thread::sleep_for(10ms);
+
   return resolveDependentMember(BaseType, ME->getMember(), NoFilter);
 }
 

clang/unittests/Sema/HeuristicResolverTest.cpp

@@ -41,7 +41,7 @@ template <typename InputNode, typename ParamT, typename InputMatcher,
           typename... OutputMatchers>
 void expectResolution(llvm::StringRef Code, ResolveFnT<ParamT> ResolveFn,
                       const InputMatcher &IM, const OutputMatchers &...OMS) {
-  auto TU = tooling::buildASTFromCodeWithArgs(Code, {"-std=c++20"});
+  auto TU = tooling::buildASTFromCodeWithArgs(Code, {"-std=c++23"});
   auto &Ctx = TU->getASTContext();
   auto InputMatches = match(IM, Ctx);
   ASSERT_EQ(1u, InputMatches.size());
@@ -449,6 +449,23 @@ TEST(HeuristicResolver, MemberExpr_DefaultTemplateArgument_Recursive) {
       cxxMethodDecl(hasName("foo")).bind("output"));
 }
 
+TEST(HeuristicResolver, MemberExpr_ExplicitObjectParameter) {
+  std::string Code = R"cpp(
+    struct Foo {
+      int m_int;
+
+      int bar(this auto&& self) {
+        return self.m_int;
+      }
+    };
+  )cpp";
+  // Test resolution of "m_int" in "self.m_int()".
+  expectResolution(
+      Code, &HeuristicResolver::resolveMemberExpr,
+      cxxDependentScopeMemberExpr(hasMemberName("m_int")).bind("input"),
+      fieldDecl(hasName("m_int")).bind("output"));
+}
+
 TEST(HeuristicResolver, DeclRefExpr_StaticMethod) {
   std::string Code = R"cpp(
     template <typename T>