[clangd] Heuristic resolution for dependent type and template names

[nridge]

Summary

Fixes https://github.com/clangd/clangd/issues/543

[hokein]

clang-tools-extra/clangd/FindTarget.cpp

128

why not using isa<TypeDecl>(D)?

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

743

can you try to add a nested struct C in B, and verify typename A<T>::B::[[C]]) still works?

[nridge]

clang-tools-extra/clangd/FindTarget.cpp

128

Heh. When I wrote this, I searched for TypeDecl via workspaceSymbols, did not see it in the first few results, and concluded that there is no such type.

Now I see it is there, just further down (and below partial matches like CFConstantStringTypeDecl). Maybe I should file a workspaceSymbols bug about this :)

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

743

Thank you for the example; this does not currently work.

Also, typename A<T>::[[B]]::C does not work either, because only the leaf type gets a DependentNameType.

I will try to get these to work.

[hokein]

clang-tools-extra/clangd/FindTarget.cpp

128

yeah, I reproduced that, I think it is probably a ranking bug -- but if you type clang::TypeDecl, you will get it from the first result.

[nridge]

Address review comments

[hokein]

clang-tools-extra/clangd/FindTarget.cpp

549

we need to be robust in resolveNestedNameSpecifierToType -- we may get a null qualifier for DependentTemplateSpecializationType, see https://reviews.llvm.org/D76320.

[nridge]

Address review comment

[hokein]

thanks.

clang-tools-extra/clangd/FindTarget.cpp

 
 const auto NonStaticFilter = [](const NamedDecl *D) {
   return D->isCXXInstanceMember();
 };
 const auto StaticFilter = [](const NamedDecl *D) {
   return !D->isCXXInstanceMember();
 };
 const auto ValueFilter = [](const NamedDecl *D) { return isa<ValueDecl>(D); };
+const auto TypeFilter = [](const NamedDecl *D) { return !isa<ValueDecl>(D); };
 
 // Given the type T of a dependent expression that appears of the LHS of a
 // "->", heuristically find a corresponding pointee type in whose scope we
 // could look up the name appearing on the RHS.
 const Type *getPointeeType(const Type *T) {
   if (!T)
     return nullptr;
 

 //  - it doesn't simplify that much, e.g. the first stage must still be able
 //    to yield multiple decls to handle OverloadExpr
 //  - there are cases where it's required for correctness. e.g:
 //      template<class X> using pvec = vector<x*>; pvec<int> x;
 //    There's no Decl `pvec<int>`, we must choose `pvec<X>` or `vector<int*>`
 //    and both are lossy. We must know upfront what the caller ultimately wants.
 //
 // FIXME: improve common dependent scope using name lookup in primary templates.
-// We currently handle DependentScopeDeclRefExpr and
-// CXXDependentScopeMemberExpr, but some other constructs remain to be handled:
-//  - DependentTemplateSpecializationType,
-//  - DependentNameType
+// We currently handle several dependent constructs, but some others remain to
+// be handled:
 //  - UnresolvedUsingTypenameDecl
 struct TargetFinder {
   using RelSet = DeclRelationSet;
   using Rel = DeclRelation;
 
 private:
   llvm::SmallDenseMap<const NamedDecl *,
                       std::pair<RelSet, /*InsertionOrder*/ size_t>>
struct Visitor : public TypeVisitor<Visitor> {
         // which is causing DTST->getDeducedType() to be empty. We
         // fall back to the template pattern and miss the instantiation
         // even when it's known in principle. Once that bug is fixed,
         // this method can be removed (the existing handling in
         // VisitDeducedType() is sufficient).
         if (auto *TD = DTST->getTemplateName().getAsTemplateDecl())
           Outer.add(TD->getTemplatedDecl(), Flags | Rel::TemplatePattern);
       }
+      void VisitDependentNameType(const DependentNameType *DNT) {
+        for (const NamedDecl *ND : getMembersReferencedViaDependentName(
+                 DNT->getQualifier()->getAsType(),
+                 [DNT](ASTContext &) { return DNT->getIdentifier(); },
+                 TypeFilter)) {
+          Outer.add(ND, Flags);
+        }
+      }
+      void VisitDependentTemplateSpecializationType(
+          const DependentTemplateSpecializationType *DTST) {
+        for (const NamedDecl *ND : getMembersReferencedViaDependentName(
+                 DTST->getQualifier()->getAsType(),
+                 [DTST](ASTContext &) { return DTST->getIdentifier(); },
+                 TypeFilter)) {
+          Outer.add(ND, Flags);
+        }
+      }
       void VisitTypedefType(const TypedefType *TT) {
         Outer.add(TT->getDecl(), Flags);
       }
       void
       VisitTemplateSpecializationType(const TemplateSpecializationType *TST) {
         // Have to handle these case-by-case.
 
         // templated type aliases: there's no specialized/instantiated using

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

Code = R"cpp(
         void test() {
           Foo::k(T()).template [[convert]]<T>();
         }
       )cpp";
   EXPECT_DECLS("CXXDependentScopeMemberExpr",
                "template <typename T> T convert() const");
 }
 
+TEST_F(TargetDeclTest, DependentTypes) {
+  Flags = {"-fno-delayed-template-parsing"};
+
+  // Heuristic resolution of dependent type name
+  Code = R"cpp(
+        template <typename>
+        struct A { struct B {}; };
+
+        template <typename T>
+        void foo(typename A<T>::[[B]]);
+      )cpp";
+  EXPECT_DECLS("DependentNameTypeLoc", "struct B");
+
+  // Heuristic resolution of dependent template name
+  Code = R"cpp(
+        template <typename>
+        struct A { 
+          template <typename> struct B {};
+        };
+
+        template <typename T>
+        void foo(typename A<T>::template [[B]]<int>);
+      )cpp";
+  EXPECT_DECLS("DependentTemplateSpecializationTypeLoc",
+               "template <typename> struct B");
+}
+
 TEST_F(TargetDeclTest, ObjC) {
   Flags = {"-xobjective-c"};
   Code = R"cpp(
     @interface Foo {}
     -(void)bar;
     @end
     void test(Foo *f) {
       [f [[bar]] ];