[clangd] Do not ignore qualifier in heuristic resolution of dependent MemberExpr

[nridge]

Summary

Fixes https://github.com/llvm/llvm-project/issues/64841

[sammccall]

Oh, this is surprising!

clang-tools-extra/clangd/HeuristicResolver.cpp

142

I think the pattern from the testcase clarifies enough to be worth an extra line

void foo() { this->Base::foo(); } shouldn't resolve to foo() itself!

[nridge]

Address review comment

clang-tools-extra/clangd/HeuristicResolver.cpp

const Type *HeuristicResolver::getPointeeType(const Type *T) const {
   const TemplateArgument &FirstArg = TST->template_arguments()[0];
   if (FirstArg.getKind() != TemplateArgument::Type)
     return nullptr;
   return FirstArg.getAsType().getTypePtrOrNull();
 }
 
 std::vector<const NamedDecl *> HeuristicResolver::resolveMemberExpr(
     const CXXDependentScopeMemberExpr *ME) const {
-  // If the expression has a qualifier, first try resolving the member
-  // inside the qualifier's type.
+  // If the expression has a qualifier, try resolving the member inside the
+  // qualifier's type.
   // Note that we cannot use a NonStaticFilter in either case, for a couple
   // of reasons:
   //   1. It's valid to access a static member using instance member syntax,
   //      e.g. `instance.static_member`.
   //   2. We can sometimes get a CXXDependentScopeMemberExpr for static
   //      member syntax too, e.g. if `X::static_member` occurs inside
   //      an instance method, it's represented as a CXXDependentScopeMemberExpr
   //      with `this` as the base expression as `X` as the qualifier
   //      (which could be valid if `X` names a base class after instantiation).
   if (NestedNameSpecifier *NNS = ME->getQualifier()) {
     if (const Type *QualifierType = resolveNestedNameSpecifierToType(NNS)) {
       auto Decls =
           resolveDependentMember(QualifierType, ME->getMember(), NoFilter);
       if (!Decls.empty())
         return Decls;
     }
+
+    // Do not proceed to try resolving the member in the expression's base type
+    // without regard to the qualifier, as that could produce incorrect results.
+    // For example, `void foo() { this->Base::foo(); }` shouldn't resolve to
+    // foo() itself!
+    return {};
   }
 
-  // If that didn't yield any results, try resolving the member inside
-  // the expression's base type.
+  // Try resolving the member inside the expression's base type.
   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

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

const char *Tests[] = {
         - (void)$decl[[howl]];
         @end
         @implementation Dog
         - (void)$def[[howl]] {}
         @end
         void play(Dog *dog) {
           [dog ho^wl];
         }
-      )objc"};
+      )objc",
+      R"cpp(
+        struct PointerIntPairInfo {
+          static void *getPointer(void *Value);
+        };
+
+        template <typename Info = PointerIntPairInfo> struct PointerIntPair {
+          void *Value;
+          void *getPointer() const { return Info::get^Pointer(Value); }
+        };
+    )cpp"};
   for (const char *Test : Tests) {
     Annotations T(Test);
     std::optional<Range> WantDecl;
     std::optional<Range> WantDef;
     if (!T.ranges().empty())
       WantDecl = WantDef = T.range();
     if (!T.ranges("decl").empty())
       WantDecl = T.range("decl");