[clang][index] report references from unreslovedLookupExpr.

[hokein]

Summary

Fix https://github.com/clangd/clangd/issues/675

[usaxena95]

Thanks. LG.
Couple of comments about adding tests to clangd as well.

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

233

Maybe add more tests to clangd/XrefsTests like the ones specifically mentioned in https://github.com/clangd/clangd/issues/399

• Ref in uninstantiated bar is reported.

template <typename T> void $decl[[foo]](T t); 
template <typename T> void bar(T t) { [[foo]](t); }
void baz(int x) { [[f^oo]](x); }

What do you think about the behaviour ?
Should we report the ref in bar in the following example ?

• ADL: May be add a negative test documenting the behaviour.

namespace ns {
struct S{};
void $decl[[foo]](S s);
}
template <typename T> void foo(T t); 
template <typename T> void bar(T t) { foo(t); } // FIXME: Maybe report this foo as a ref to ns::foo when bar<ns::S> is instantiated?
void baz(int x) { 
  ns::S s;
  bar<ns::S>(s);
  [[f^oo]](s); 
}

[hokein]

address comment, add more tests.

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

const char *Tests[] = {
       )cpp",
       R"cpp(// Renaming alias
         template <typename> class Vector {};
         using $def[[^X]] = Vector<int>;
         [[X]] x1;
         Vector<int> x2;
         Vector<double> y;
       )cpp",
+      R"cpp(// Dependent code
+        template <typename T> void $decl[[foo]](T t);
+        template <typename T> void bar(T t) { [[foo]](t); } // foo in bar is uninstantiated.
+        void baz(int x) { [[f^oo]](x); }
+      )cpp",
+      R"cpp(
+        namespace ns {
+        struct S{};
+        void $decl[[foo]](S s);
+        } // namespace ns
+        template <typename T> void foo(T t);
+        // FIXME: Maybe report this foo as a ref to ns::foo (because of ADL)
+        // 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",
   };
   for (const char *Test : Tests)
     checkFindRefs(Test);
 }
 
 TEST(FindReferences, IncludeOverrides) {
   llvm::StringRef Test =
       R"cpp(

clang/lib/Index/IndexBody.cpp

bool VisitParmVarDecl(ParmVarDecl* D) {
     // Index the parameters of lambda expression.
     if (IndexCtx.shouldIndexFunctionLocalSymbols()) {
       const auto *DC = D->getDeclContext();
       if (DC && isLambdaCallOperator(DC))
         IndexCtx.handleDecl(D);
     }
     return true;
   }
+
+  bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *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;
+  }
 };
 
 } // anonymous namespace
 
 void IndexingContext::indexBody(const Stmt *S, const NamedDecl *Parent,
                                 const DeclContext *DC) {
   if (!S)
     return;
 
   if (!DC)
     DC = Parent->getLexicalDeclContext();
   BodyIndexer(*this, Parent, DC).TraverseStmt(const_cast<Stmt*>(S));
 }

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

 struct UsingE : public UsingD<T>, public UsingD<U> {
 // CHECK: [[@LINE+2]]:20 | using/using-value(Gen)/C++ | foo | c:index-dependent-source.cpp@ST>2#T#T@UsingE@UUV@UsingD<T>::foo | <no-cgname> | Decl,RelChild | rel: 1
 // CHECK: [[@LINE+1]]:9 | struct(Gen)/C++ | UsingD | c:@ST>1#T@UsingD | <no-cgname> | Ref,RelCont | rel: 1
   using UsingD<T>::foo;
 // CHECK: [[@LINE+2]]:20 | using/using-value(Gen)/C++ | foo | c:index-dependent-source.cpp@ST>2#T#T@UsingE@UUV@UsingD<U>::foo | <no-cgname> | Decl,RelChild | rel: 1
 // CHECK: [[@LINE+1]]:9 | struct(Gen)/C++ | UsingD | c:@ST>1#T@UsingD | <no-cgname> | Ref,RelCont | rel: 1
   using UsingD<U>::foo;
 };
+
+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
+}