[clang][index] Index unresolved member expression as reference

[denis-fatkulin]

Summary

Unresolved member expressions aren't indexed as references.

Example code:

struct Foo {
  template <typename T> void bar(T t); 
};
template <typename T> void test(Foo F, T t) {
  F.bar(t); // Not indexed
}

[denis-fatkulin]

clangd unit test fixed

[denis-fatkulin]

Broken tests are deleted

[hokein]

Thanks!

[denis-fatkulin]

@hokein, could you please also merge my pacth to code base? I haven't such permissions yet.
My git user name and address: Denis Fatkulin ([e-mail])

Thank you for the review!

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

 //===-- XRefsTests.cpp  ---------------------------*- C++ -*--------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "Annotations.h"
const char *Tests[] = {
         // when bar<ns::S> is instantiated?
         template <typename T> void bar(T t) { foo(t); }
         void baz(int x) {
           ns::S s;
           bar<ns::S>(s);
           [[f^oo]](s);
         }
       )cpp",
+      R"cpp(// unresolved member expression
+        struct Foo {
+          template <typename T> void $decl[[bar]](T t); 
+        };
+        template <typename T> void test(Foo F, T t) {
+          F.[[b^ar]](t);
+        }
+      )cpp",
 
       // Enum base
       R"cpp(
         typedef int $def[[MyTypeD^ef]];
         enum MyEnum : [[MyTy^peDef]] { };
       )cpp",
       R"cpp(
         typedef int $def[[MyType^Def]];

clang/lib/Index/IndexBody.cpp

 //===- IndexBody.cpp - Indexing statements --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
bool VisitParmVarDecl(ParmVarDecl* D) {
     if (IndexCtx.shouldIndexFunctionLocalSymbols()) {
       const auto *DC = D->getDeclContext();
       if (DC && (isLambdaCallOperator(DC) || isa<RequiresExprBodyDecl>(DC)))
         IndexCtx.handleDecl(D);
     }
     return true;
   }
 
-  bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
+  bool VisitOverloadExpr(OverloadExpr *E) {
     SmallVector<SymbolRelation, 4> Relations;
     SymbolRoleSet Roles = getRolesForRef(E, Relations);
     for (auto *D : E->decls())
       IndexCtx.handleReference(D, E->getNameLoc(), Parent, ParentDC, Roles,
                                Relations, E);
     return true;
   }
 

clang/test/Index/Core/index-dependent-source.cpp

 };
 
 template <typename T> void foo();
 // CHECK: [[@LINE-1]]:28 | function/C | foo | c:@FT@>1#Tfoo#v# | <no-cgname> | Decl | rel: 0
 template <typename T> void bar() {
   foo<T>();
 // CHECK: [[@LINE-1]]:3 | function/C | foo | c:@FT@>1#Tfoo#v# | <no-cgname> | Ref,Call,RelCall,RelCont | rel: 1
 }
+
+struct Foo {
+  template <typename T> void bar();
+  // CHECK: [[@LINE-1]]:30 | instance-method/C++ | bar | c:@S@Foo@FT@>1#Tbar#v# | <no-cgname> | Decl,RelChild | rel: 1
+};
+template <typename T> void baz(Foo f) {
+  f.bar<T>();
+  // CHECK: [[@LINE-1]]:5 | instance-method/C++ | bar | c:@S@Foo@FT@>1#Tbar#v# | <no-cgname> | Ref,Call,RelCall,RelCont | rel: 1
+}

clang/unittests/Index/IndexTests.cpp

 //===--- IndexTests.cpp - Test indexing actions -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
TEST(IndexTest, EnumBase) {
   tooling::runToolOnCode(std::make_unique<IndexAction>(Index), Code);
   EXPECT_THAT(
       Index->Symbols,
       AllOf(Contains(AllOf(QName("MyTypedef"), HasRole(SymbolRole::Reference),
                            WrittenAt(Position(3, 16)))),
             Contains(AllOf(QName("MyTypedef"), HasRole(SymbolRole::Reference),
                            WrittenAt(Position(4, 16))))));
 }
+
+TEST(IndexTest, UnresolvedLookupExpr) {
+  std::string Code = R"cpp(
+    template <typename T> void foo(T t);
+    template <typename T> void test(T t) {
+      foo(t);
+    }
+  )cpp";
+  auto Index = std::make_shared<Indexer>();
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index), Code);
+  EXPECT_THAT(Index->Symbols,
+              Contains(AllOf(QName("foo"), HasRole(SymbolRole::Reference),
+                             WrittenAt(Position(4, 7)))));
+}
+
+TEST(IndexTest, UnresolvedMemberExpr) {
+  std::string Code = R"cpp(
+    struct Foo {
+      template <typename T> void bar(T t);
+    };
+    template <typename T> void test(Foo F, T t) {
+      F.bar(t);
+    }
+  )cpp";
+  auto Index = std::make_shared<Indexer>();
+  tooling::runToolOnCode(std::make_unique<IndexAction>(Index), Code);
+  EXPECT_THAT(Index->Symbols,
+              Contains(AllOf(QName("Foo::bar"), HasRole(SymbolRole::Reference),
+                             WrittenAt(Position(6, 9)))));
+}
 } // namespace
 } // namespace index
 } // namespace clang