[clangd] Improve heuristic resolution of dependent types in TargetFinder

[nridge]

Summary

• Try to apply heuristic resolution recursively to the base expression of a CXXDependentScopeMemberExpr.
• Try to apply heuristic resolution recursively to the callee expression in a call expression.

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

[nridge]

Adding some reviewers.

[hokein]

looks like we use this heuristic for go-to-def, I think we might want to use it in more places, e.g. libindex (for xrefs), sema code completion (so that this->a.^ can suggest something).

clang-tools-extra/clangd/FindTarget.cpp

254

I think this is the key point of the fix?

It would be nice if you could find a way to split it into two (one for refactoring, one for the fix). The diff of this patch contains large chunk of refactoring changes which make the fix less obvious.

[nridge]

In D82739#2133155, @hokein wrote:

looks like we use this heuristic for go-to-def, I think we might want to use it in more places, e.g. libindex (for xrefs), sema code completion (so that this->a.^ can suggest something).

Yeah, this is a great point. I would definitely like to reuse this heuristic resolution for other features like code completion (including in https://github.com/clangd/clangd/issues/443 where I hope to build on it to improve the original STR which involves completion).

I will explore relocating this code to a place where things like code completion can reuse it, in a follow-up patch.

clang-tools-extra/clangd/FindTarget.cpp

254

Yeah, sorry about that. I've split the patch and cleaned it up further (to avoid unnecessary reordering of functions) to make the diff neater.

[nridge]

Split patch

[nridge]

Split out the refactoring into D83371 which this depends on now.

[nridge]

Improve patch split

[hokein]

In D82739#2138260, @nridge wrote:

In D82739#2133155, @hokein wrote:

looks like we use this heuristic for go-to-def, I think we might want to use it in more places, e.g. libindex (for xrefs), sema code completion (so that this->a.^ can suggest something).

Yeah, this is a great point. I would definitely like to reuse this heuristic resolution for other features like code completion (including in https://github.com/clangd/clangd/issues/443 where I hope to build on it to improve the original STR which involves completion).

I will explore relocating this code to a place where things like code completion can reuse it, in a follow-up patch.

thanks, this sounds a good plan.

clang-tools-extra/clangd/FindTarget.cpp

171–172

I'm doubting whether we will miss some other exprs, since we are using it to find the decls for the base expr of CXXDependentScopeMemberExpr.

could you try the following testcase (also add it to the unittest)?

struct A {
  void foo() {}
};
struct B {
  A getA();
};

template <typename T> struct C {
  C c;

  void bar() { this->c.getA().foo(); }
};

254

it looks better now, thanks!

[nridge]

Address review comments

clang-tools-extra/clangd/FindTarget.cpp

171–172

Thank you for the example! Handling this case required a bit of additional logic, which I've now added.

[hokein]

clang-tools-extra/clangd/FindTarget.cpp

71

an off-topic comment: I don't have a reproduce case, but I think we might get a nullptr, and get a null-access crash below,

87

nit: the "a dependent type" doesn't seem to be correct, the type is not always dependent, I'd use a tag-decl type.

101

this function was pretty clear prior to the patch -- given a tag-decl type, and a member name, it tries to perform a lookup in the tag-decl, and returns the result.

Now we add an extra&optional E which seems making it tangled, there is only one caller passing the actual E, so I think we should keep this helper function as-is, and handle the builtin-dependent type in the caller.

197

btw, could you try the case below? it doesn't seem to work.

struct Bar {
  int aaaa;
};
template <typename T> struct Foo {
  Bar func(int);
  void test() {
    func(1).aa^aa;
  }
};

198

we need to check whether the type is null, otherwise we get a crash below.

see:

template<typename T>
struct Foo {
  int func(int);
  void test() {
    func().a;
  }
};

199

could you add a unittest for this case?

nit: I'd remove the extra {} if the if body just contains a single statement.

287

this FIXME looks stale now, could you please update it?

[nridge]

Address review comments

clang-tools-extra/clangd/FindTarget.cpp

197

Thanks for the additional example. To make this work I had to handle one more case (MemberExpr) in resolveDependentExprToDecls().

287

I think the FIXME is still relevant. While we handle DependentScopeDeclRefExpr and CXXDependentScopeMemberExpr, we still do not handle the AST node types listed in the comment.

For example, we do not handle:

template <typename>
struct A {
  typedef int [[type]];
};

template <typename T>
struct B {
  typedef typename A<T>::t^ype type;
};

(I believe that one would be DependentNameType? You can imagine similar scenarios involving using-decls etc.)

However, the example in the FIXME (which depicts a CXXDependentScopeMemberExpr) is now stale, so I've removed it and clarified the comment a bit.

[hokein]

thanks, looks good.

clang-tools-extra/clangd/FindTarget.cpp

67

nit: remove the {}, and elsewhere.

88

I'd move resolveDependentExprToType close to resolveDependentExprToDecls (they are quite related).

consider putting resolveDependentExprToType after resolveDependentExprToDecls definition, and add a forward declaration of resolveDependentExprToType before the resolveDependentExprToDecls.

178

nit: move the Base to the if below.

182

nit: b -> by

185

this branch is redundant, we can remove it, since getMembersReferencedViaDependentName can handle a nullptr.

[nridge]

Address remaining comments

[hokein]

clang-tools-extra/clangd/FindTarget.cpp

172

@nridge, the assertion is not true anymore, since we have extended it to support possibly-non-dependent expressions (callExpr, MemberExpr).

we hit this assert when opening clang/include/clang/ASTMatchers/ASTMatchers.h. I think we probably need to remove it and rename related function names.

[hokein]

clang-tools-extra/clangd/FindTarget.cpp

172

a reduce case:

template<typename T>
class Foo {
public:
    int foo();
};

class Bar {
public:
static void k();
template <typename T> T convert() const;
};

void func();
template <typename T>
void foo2(Foo<T> t) {
    Bar::k(t.foo()).template convert<T>();
}

clang-tools-extra/clangd/FindTarget.cpp

std::string S = std::string(N.getNodeKind().asStringRef());
     OS << ": ";
     N.print(OS, PrintingPolicy(LangOptions()));
   }
   std::replace(S.begin(), S.end(), '\n', ' ');
   return S;
 }
 
 // Helper function for getMembersReferencedViaDependentName()
-// which takes a dependent type `T` and heuristically
+// which takes a possibly-dependent type `T` and heuristically
 // resolves it to a CXXRecordDecl in which we can try name lookup.
 CXXRecordDecl *resolveTypeToRecordDecl(const Type *T) {
   assert(T);
-  if (const auto *ICNT = T->getAs<InjectedClassNameType>()) {
+
+  if (const auto *RT = T->getAs<RecordType>())
+    return dyn_cast<CXXRecordDecl>(RT->getDecl());
+
+  if (const auto *ICNT = T->getAs<InjectedClassNameType>())
     T = ICNT->getInjectedSpecializationType().getTypePtrOrNull();
-  }
+  if (!T)
+    return nullptr;
+
   const auto *TST = T->getAs<TemplateSpecializationType>();
   if (!TST)
     return nullptr;
+
   const ClassTemplateDecl *TD = dyn_cast_or_null<ClassTemplateDecl>(
       TST->getTemplateName().getAsTemplateDecl());
   if (!TD)
     return nullptr;
+
   return TD->getTemplatedDecl();
 }
 
-// Given a dependent type and a member name, heuristically resolve the
+// Given a tag-decl type and a member name, heuristically resolve the
 // name to one or more declarations.
 // The current heuristic is simply to look up the name in the primary
 // template. This is a heuristic because the template could potentially
 // have specializations that declare different members.
 // Multiple declarations could be returned if the name is overloaded
 // (e.g. an overloaded method in the primary template).
 // This heuristic will give the desired answer in many cases, e.g.
 // for a call to vector<T>::size().
 // The name to look up is provided in the form of a factory that takes
 // an ASTContext, because an ASTContext may be needed to obtain the
 // name (e.g. if it's an operator name), but the caller may not have
 // access to an ASTContext.
 std::vector<const NamedDecl *> getMembersReferencedViaDependentName(
     const Type *T,
     llvm::function_ref<DeclarationName(ASTContext &)> NameFactory,
     bool IsNonstaticMember) {
   if (!T)
     return {};
   if (auto *ET = T->getAs<EnumType>()) {
     auto Result =
         ET->getDecl()->lookup(NameFactory(ET->getDecl()->getASTContext()));
     return {Result.begin(), Result.end()};
const Type *getPointeeType(const Type *T) {
   if (TST->getNumArgs() == 0)
     return nullptr;
   const TemplateArgument &FirstArg = TST->getArg(0);
   if (FirstArg.getKind() != TemplateArgument::Type)
     return nullptr;
   return FirstArg.getAsType().getTypePtrOrNull();
 }
 
+// Forward declaration, needed as this function is mutually recursive
+// with resolveDependentExprToDecls.
+const Type *resolveDependentExprToType(const Expr *E);
+
 // Try to heuristically resolve a dependent expression `E` to one
 // or more declarations that it likely references.
 std::vector<const NamedDecl *> resolveDependentExprToDecls(const Expr *E) {
   assert(E->isTypeDependent());
   if (const auto *ME = dyn_cast<CXXDependentScopeMemberExpr>(E)) {
     const Type *BaseType = ME->getBaseType().getTypePtrOrNull();
     if (ME->isArrow()) {
       BaseType = getPointeeType(BaseType);
     }
+    if (const auto *BT = BaseType->getAs<BuiltinType>()) {
+      // If BaseType is the type of a dependent expression, it's just
+      // represented as BultinType::Dependent which gives us no information. We
+      // can get further by analyzing the depedent expression.
+      Expr *Base = ME->isImplicitAccess() ? nullptr : ME->getBase();
+      if (Base && BT->getKind() == BuiltinType::Dependent) {
+        BaseType = resolveDependentExprToType(Base);
+      }
+    }
     return getMembersReferencedViaDependentName(
         BaseType, [ME](ASTContext &) { return ME->getMember(); },
         /*IsNonstaticMember=*/true);
   }
   if (const auto *RE = dyn_cast<DependentScopeDeclRefExpr>(E)) {
     return getMembersReferencedViaDependentName(
         RE->getQualifier()->getAsType(),
         [RE](ASTContext &) { return RE->getDeclName(); },
         /*IsNonstaticMember=*/false);
   }
+  if (const auto *CE = dyn_cast<CallExpr>(E)) {
+    const auto *CalleeType = resolveDependentExprToType(CE->getCallee());
+    if (!CalleeType)
       return {};
+    if (const auto *FnTypePtr = CalleeType->getAs<PointerType>())
+      CalleeType = FnTypePtr->getPointeeType().getTypePtr();
+    if (const FunctionType *FnType = CalleeType->getAs<FunctionType>()) {
+      if (const auto *D =
+              resolveTypeToRecordDecl(FnType->getReturnType().getTypePtr())) {
+        return {D};
+      }
+    }
+  }
+  if (const auto *ME = dyn_cast<MemberExpr>(E)) {
+    return {ME->getMemberDecl()};
+  }
+  return {};
+}
+
+// Try to heuristically resolve the type of a dependent expression `E`.
+const Type *resolveDependentExprToType(const Expr *E) {
+  std::vector<const NamedDecl *> Decls = resolveDependentExprToDecls(E);
+  if (Decls.size() != 1) // Names an overload set -- just bail.
+    return nullptr;
+  if (const auto *TD = dyn_cast<TypeDecl>(Decls[0])) {
+    return TD->getTypeForDecl();
+  } else if (const auto *VD = dyn_cast<ValueDecl>(Decls[0])) {
+    return VD->getType().getTypePtrOrNull();
+  }
+  return nullptr;
 }
 
 const NamedDecl *getTemplatePattern(const NamedDecl *D) {
   if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) {
     if (const auto *Result = CRD->getTemplateInstantiationPattern())
       return Result;
     // getTemplateInstantiationPattern returns null if the Specialization is
     // incomplete (e.g. the type didn't need to be complete), fall back to the
if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) {
     return ED->getInstantiatedFromMemberEnum();
   } else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D)) {
     if (const auto *Parent = llvm::dyn_cast<NamedDecl>(D->getDeclContext()))
       if (const DeclContext *ParentPat =
               dyn_cast_or_null<DeclContext>(getTemplatePattern(Parent)))
         for (const NamedDecl *BaseND : ParentPat->lookup(D->getDeclName()))
           if (!BaseND->isImplicit() && BaseND->getKind() == D->getKind())
             return BaseND;
   } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(D)) {
     if (const auto *ED = dyn_cast<EnumDecl>(ECD->getDeclContext())) {
       if (const EnumDecl *Pattern = ED->getInstantiatedFromMemberEnum()) {
         for (const NamedDecl *BaseECD : Pattern->lookup(ECD->getDeclName()))
           return BaseECD;
       }
     }
   }
   return nullptr;

 //    typedef reveals a decltype which must be traversed)
 //  - 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.
-// e.g. template<typename T> int foo() { return std::vector<T>().size(); }
-// formally size() is unresolved, but the primary template is a good guess.
-// This affects:
+// We currently handle DependentScopeDeclRefExpr and
+// CXXDependentScopeMemberExpr, but some other constructs remain to be handled:
 //  - DependentTemplateSpecializationType,
 //  - DependentNameType
 //  - UnresolvedUsingValueDecl
 //  - UnresolvedUsingTypenameDecl
 struct TargetFinder {
   using RelSet = DeclRelationSet;
   using Rel = DeclRelation;
 

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

Code = R"cpp(
     template <class T>
     void foo(X x, T t) {
       x.[[func]](t);
     };
   )cpp";
   EXPECT_DECLS("UnresolvedMemberExpr", "void func(int *)", "void func(char *)");
 }
 
+TEST_F(TargetDeclTest, DependentExprs) {
+  Flags = {"-fno-delayed-template-parsing"};
+
+  // Heuristic resolution of method of dependent field
+  Code = R"cpp(
+        struct A { void foo() {} };
+        template <typename T>
+        struct B {
+          A a;
+          void bar() {
+            this->a.[[foo]]();
+          }
+        };
+      )cpp";
+  EXPECT_DECLS("CXXDependentScopeMemberExpr", "void foo()");
+
+  // Similar to above but base expression involves a function call.
+  Code = R"cpp(
+        struct A {
+          void foo() {}
+        };
+        struct B {
+          A getA();
+        };
+        template <typename T>
+        struct C {
+          B c;
+          void bar() {
+            this->c.getA().[[foo]]();
+          }
+        };
+      )cpp";
+  EXPECT_DECLS("CXXDependentScopeMemberExpr", "void foo()");
+
+  // Similar to above but uses a function pointer.
+  Code = R"cpp(
+        struct A {
+          void foo() {}
+        };
+        struct B {
+          using FPtr = A(*)();
+          FPtr fptr;
+        };
+        template <typename T>
+        struct C {
+          B c;
+          void bar() {
+            this->c.fptr().[[foo]]();
+          }
+        };
+      )cpp";
+  EXPECT_DECLS("CXXDependentScopeMemberExpr", "void foo()");
+
+  // Base expression involves a member access into this.
+  Code = R"cpp(
+        struct Bar {
+          int aaaa;
+        };
+        template <typename T> struct Foo {
+          Bar func(int);
+          void test() {
+            func(1).[[aaaa]];
+          }
+        };
+      )cpp";
+  EXPECT_DECLS("CXXDependentScopeMemberExpr", "int aaaa");
+}
+
 TEST_F(TargetDeclTest, ObjC) {
   Flags = {"-xobjective-c"};
   Code = R"cpp(
     @interface Foo {}
     -(void)bar;
     @end
     void test(Foo *f) {
       [f [[bar]] ];
for (unsigned I = 0; I < Refs.size(); ++I)
       DumpedReferences += std::string(llvm::formatv("{0}: {1}\n", I, Refs[I]));
 
     return AllRefs{std::move(AnnotatedCode), std::move(DumpedReferences)};
   }
 };
 
 TEST_F(FindExplicitReferencesTest, All) {
   std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
-      {// Simple expressions.
+      {
+          // Simple expressions.
           {R"cpp(
         int global;
         int func();
         void foo(int param) {
           $0^global = $1^param + $2^func();
         }
         )cpp",
            "0: targets = {global}\n"
            "1: targets = {param}\n"
            "2: targets = {func}\n"},
           {R"cpp(
         struct X { int a; };
         void foo(X x) {
           $0^x.$1^a = 10;
         }
         )cpp",
            "0: targets = {x}\n"
            "1: targets = {X::a}\n"},
           {R"cpp(
         // error-ok: testing with broken code
         int bar();
         int foo() {
           return $0^bar() + $1^bar(42);
         }
         )cpp",
            "0: targets = {bar}\n"
            "1: targets = {bar}\n"},
           // Namespaces and aliases.
           {R"cpp(
           namespace ns {}
           namespace alias = ns;
           void foo() {
             using namespace $0^ns;
             using namespace $1^alias;
           }
         )cpp",
            "0: targets = {ns}\n"
            "1: targets = {alias}\n"},
           // Using declarations.
           {R"cpp(
           namespace ns { int global; }
           void foo() {
             using $0^ns::$1^global;
           }
         )cpp",
            "0: targets = {ns}\n"
            "1: targets = {ns::global}, qualifier = 'ns::'\n"},
           // Simple types.
           {R"cpp(
          struct Struct { int a; };
          using Typedef = int;
          void foo() {
            $0^Struct $1^x;
            $2^Typedef $3^y;
            static_cast<$4^Struct*>(0);
          }
        )cpp",
            "0: targets = {Struct}\n"
            "1: targets = {x}, decl\n"
            "2: targets = {Typedef}\n"
            "3: targets = {y}, decl\n"
            "4: targets = {Struct}\n"},
           // Name qualifiers.
           {R"cpp(
          namespace a { namespace b { struct S { typedef int type; }; } }
          void foo() {
            $0^a::$1^b::$2^S $3^x;
            using namespace $4^a::$5^b;
            $6^S::$7^type $8^y;
          }
         )cpp",
            "0: targets = {a}\n"
            "1: targets = {a::b}, qualifier = 'a::'\n"
            "2: targets = {a::b::S}, qualifier = 'a::b::'\n"
            "3: targets = {x}, decl\n"
            "4: targets = {a}\n"
            "5: targets = {a::b}, qualifier = 'a::'\n"
            "6: targets = {a::b::S}\n"
            "7: targets = {a::b::S::type}, qualifier = 'struct S::'\n"
            "8: targets = {y}, decl\n"},
           {R"cpp(
          void foo() {
            $0^ten: // PRINT "HELLO WORLD!"
            goto $1^ten;
          }
        )cpp",
         "0: targets = {ten}, decl\n"
         "1: targets = {ten}\n"},
        // Simple templates.
        {R"cpp(
           template <class T> struct vector { using value_type = T; };
           template <> struct vector<bool> { using value_type = bool; };
           void foo() {
             $0^vector<int> $1^vi;
             $2^vector<bool> $3^vb;
           }
         )cpp",
            "0: targets = {vector<int>}\n"
            "1: targets = {vi}, decl\n"
            "2: targets = {vector<bool>}\n"
            "3: targets = {vb}, decl\n"},
           // Template type aliases.
           {R"cpp(
             template <class T> struct vector { using value_type = T; };
             template <> struct vector<bool> { using value_type = bool; };
             template <class T> using valias = vector<T>;
             void foo() {
               $0^valias<int> $1^vi;
               $2^valias<bool> $3^vb;
             }
           )cpp",
            "0: targets = {valias}\n"
            "1: targets = {vi}, decl\n"
            "2: targets = {valias}\n"
            "3: targets = {vb}, decl\n"},
           // Injected class name.
           {R"cpp(
             namespace foo {
               template <typename $0^T>
               class $1^Bar {
                 ~$2^Bar();
                 void $3^f($4^Bar);
               };
             }
           )cpp",
            "0: targets = {foo::Bar::T}, decl\n"
            "1: targets = {foo::Bar}, decl\n"
            "2: targets = {foo::Bar}\n"
            "3: targets = {foo::Bar::f}, decl\n"
            "4: targets = {foo::Bar}\n"},
           // MemberExpr should know their using declaration.
           {R"cpp(
             struct X { void func(int); };
             struct Y : X {
               using X::func;
             };
             void foo(Y y) {
               $0^y.$1^func(1);
             }
         )cpp",
            "0: targets = {y}\n"
            "1: targets = {Y::func}\n"},
           // DeclRefExpr should know their using declaration.
           {R"cpp(
             namespace ns { void bar(int); }
             using ns::bar;
 
             void foo() {
               $0^bar(10);
             }
         )cpp",
            "0: targets = {bar}\n"},
           // References from a macro.
           {R"cpp(
             #define FOO a
             #define BAR b
 
             void foo(int a, int b) {
               $0^FOO+$1^BAR;
             }
         )cpp",
            "0: targets = {a}\n"
            "1: targets = {b}\n"},
           // No references from implicit nodes.
           {R"cpp(
             struct vector {
               int *begin();
               int *end();
             };
 
             void foo() {
               for (int $0^x : $1^vector()) {
                 $2^x = 10;
               }
             }
         )cpp",
            "0: targets = {x}, decl\n"
            "1: targets = {vector}\n"
            "2: targets = {x}\n"},
 // Handle UnresolvedLookupExpr.
 // FIXME
 // This case fails when expensive checks are enabled.
 // Seems like the order of ns1::func and ns2::func isn't defined.
 #ifndef EXPENSIVE_CHECKS
           {R"cpp(
             namespace ns1 { void func(char*); }
             namespace ns2 { void func(int*); }
             using namespace ns1;
             using namespace ns2;
 
             template <class T>
             void foo(T t) {
               $0^func($1^t);
             }
         )cpp",
            "0: targets = {ns1::func, ns2::func}\n"
            "1: targets = {t}\n"},
 #endif
           // Handle UnresolvedMemberExpr.
           {R"cpp(
             struct X {
               void func(char*);
               void func(int*);
             };
 
             template <class T>
             void foo(X x, T t) {
               $0^x.$1^func($2^t);
             }
         )cpp",
            "0: targets = {x}\n"
            "1: targets = {X::func, X::func}\n"
            "2: targets = {t}\n"},
           // Handle DependentScopeDeclRefExpr.
           {R"cpp(
             template <class T>
             struct S {
               static int value;
             };
 
             template <class T>
             void foo() {
               $0^S<$1^T>::$2^value;
             }
        )cpp",
            "0: targets = {S}\n"
            "1: targets = {T}\n"
            "2: targets = {S::value}, qualifier = 'S<T>::'\n"},
           // Handle CXXDependentScopeMemberExpr.
           {R"cpp(
             template <class T>
             struct S {
               int value;
             };
 
             template <class T>
             void foo(S<T> t) {
               $0^t.$1^value;
             }
        )cpp",
            "0: targets = {t}\n"
            "1: targets = {S::value}\n"},
           // Type template parameters.
           {R"cpp(
             template <class T>
             void foo() {
               static_cast<$0^T>(0);
               $1^T();
               $2^T $3^t;
             }
         )cpp",
            "0: targets = {T}\n"
            "1: targets = {T}\n"
            "2: targets = {T}\n"
            "3: targets = {t}, decl\n"},
           // Non-type template parameters.
           {R"cpp(
             template <int I>
             void foo() {
               int $0^x = $1^I;
             }
         )cpp",
            "0: targets = {x}, decl\n"
            "1: targets = {I}\n"},
           // Template template parameters.
           {R"cpp(
             template <class T> struct vector {};
 
             template <template<class> class TT, template<class> class ...TP>
             void foo() {
               $0^TT<int> $1^x;
               $2^foo<$3^TT>();
               $4^foo<$5^vector>();
               $6^foo<$7^TP...>();
             }
         )cpp",
            "0: targets = {TT}\n"
            "1: targets = {x}, decl\n"
            "2: targets = {foo}\n"
            "3: targets = {TT}\n"
            "4: targets = {foo}\n"
            "5: targets = {vector}\n"
            "6: targets = {foo}\n"
            "7: targets = {TP}\n"},
           // Non-type template parameters with declarations.
           {R"cpp(
             int func();
             template <int(*)()> struct wrapper {};
 
             template <int(*FuncParam)()>
             void foo() {
               $0^wrapper<$1^func> $2^w;
               $3^FuncParam();
             }
         )cpp",
            "0: targets = {wrapper<&func>}\n"
            "1: targets = {func}\n"
            "2: targets = {w}, decl\n"
            "3: targets = {FuncParam}\n"},
           // declaration references.
           {R"cpp(
              namespace ns {}
              class S {};
              void foo() {
                class $0^Foo { $1^Foo(); ~$2^Foo(); int $3^field; };
                int $4^Var;
                enum $5^E { $6^ABC };
                typedef int $7^INT;
                using $8^INT2 = int;
                namespace $9^NS = $10^ns;
              }
            )cpp",
            "0: targets = {Foo}, decl\n"
            "1: targets = {foo()::Foo::Foo}, decl\n"
            "2: targets = {Foo}\n"
            "3: targets = {foo()::Foo::field}, decl\n"
            "4: targets = {Var}, decl\n"
            "5: targets = {E}, decl\n"
            "6: targets = {foo()::ABC}, decl\n"
            "7: targets = {INT}, decl\n"
            "8: targets = {INT2}, decl\n"
            "9: targets = {NS}, decl\n"
            "10: targets = {ns}\n"},
           // User-defined conversion operator.
           {R"cpp(
             void foo() {
                class $0^Bar {};
                class $1^Foo {
                public:
                  // FIXME: This should have only one reference to Bar.
                  $2^operator $3^$4^Bar();
                };
 
                $5^Foo $6^f;
                $7^f.$8^operator $9^Bar();
             }
         )cpp",
            "0: targets = {Bar}, decl\n"
            "1: targets = {Foo}, decl\n"
            "2: targets = {foo()::Foo::operator Bar}, decl\n"
            "3: targets = {Bar}\n"
            "4: targets = {Bar}\n"
            "5: targets = {Foo}\n"
            "6: targets = {f}, decl\n"
            "7: targets = {f}\n"
            "8: targets = {foo()::Foo::operator Bar}\n"
            "9: targets = {Bar}\n"},
           // Destructor.
           {R"cpp(
              void foo() {
                class $0^Foo {
                public:
                  ~$1^Foo() {}
 
                  void $2^destructMe() {
                    this->~$3^Foo();
                  }
                };
 
                $4^Foo $5^f;
                $6^f.~ /*...*/ $7^Foo();
              }
            )cpp",
            "0: targets = {Foo}, decl\n"
            // FIXME: It's better to target destructor's FunctionDecl instead of
            // the type itself (similar to constructor).
            "1: targets = {Foo}\n"
            "2: targets = {foo()::Foo::destructMe}, decl\n"
            "3: targets = {Foo}\n"
            "4: targets = {Foo}\n"
            "5: targets = {f}, decl\n"
            "6: targets = {f}\n"
            "7: targets = {Foo}\n"},
           // cxx constructor initializer.
           {R"cpp(
              class Base {};
              void foo() {
                // member initializer
                class $0^X {
                  int $1^abc;
                  $2^X(): $3^abc() {}
                };
                // base initializer
                class $4^Derived : public $5^Base {
                  $6^Base $7^B;
                  $8^Derived() : $9^Base() {}
                };
                // delegating initializer
                class $10^Foo {
                  $11^Foo(int);
                  $12^Foo(): $13^Foo(111) {}
                };
              }
            )cpp",
            "0: targets = {X}, decl\n"
            "1: targets = {foo()::X::abc}, decl\n"
            "2: targets = {foo()::X::X}, decl\n"
            "3: targets = {foo()::X::abc}\n"
            "4: targets = {Derived}, decl\n"
            "5: targets = {Base}\n"
            "6: targets = {Base}\n"
            "7: targets = {foo()::Derived::B}, decl\n"
            "8: targets = {foo()::Derived::Derived}, decl\n"
            "9: targets = {Base}\n"
            "10: targets = {Foo}, decl\n"
            "11: targets = {foo()::Foo::Foo}, decl\n"
            "12: targets = {foo()::Foo::Foo}, decl\n"
            "13: targets = {Foo}\n"},
           // Anonymous entities should not be reported.
           {
               R"cpp(
              void foo() {
               class {} $0^x;
               int (*$1^fptr)(int $2^a, int) = nullptr;
              }
            )cpp",
               "0: targets = {x}, decl\n"
               "1: targets = {fptr}, decl\n"
               "2: targets = {a}, decl\n"},
           // Namespace aliases should be handled properly.
           {
               R"cpp(
                 namespace ns { struct Type {}; }
                 namespace alias = ns;
                 namespace rec_alias = alias;
 
                 void foo() {
                   $0^ns::$1^Type $2^a;
                   $3^alias::$4^Type $5^b;
                   $6^rec_alias::$7^Type $8^c;
                 }
            )cpp",
               "0: targets = {ns}\n"
               "1: targets = {ns::Type}, qualifier = 'ns::'\n"
               "2: targets = {a}, decl\n"
               "3: targets = {alias}\n"
               "4: targets = {ns::Type}, qualifier = 'alias::'\n"
               "5: targets = {b}, decl\n"
               "6: targets = {rec_alias}\n"
               "7: targets = {ns::Type}, qualifier = 'rec_alias::'\n"
               "8: targets = {c}, decl\n"},
           // Handle SizeOfPackExpr.
           {
               R"cpp(
                 template <typename... E>
                 void foo() {
                   constexpr int $0^size = sizeof...($1^E);
                 };
             )cpp",
               "0: targets = {size}, decl\n"
               "1: targets = {E}\n"},
           // Class template argument deduction
           {
               R"cpp(
                 template <typename T>
                 struct Test {
                 Test(T);
               };
               void foo() {
                 $0^Test $1^a(5);
               }
             )cpp",
               "0: targets = {Test}\n"
               "1: targets = {a}, decl\n"},
           // Templates
           {R"cpp(
             namespace foo {
               template <typename $0^T>
               class $1^Bar {};
             }
           )cpp",
            "0: targets = {foo::Bar::T}, decl\n"
            "1: targets = {foo::Bar}, decl\n"},
           // Templates
           {R"cpp(
             namespace foo {
               template <typename $0^T>
               void $1^func();
             }
           )cpp",
            "0: targets = {T}, decl\n"
            "1: targets = {foo::func}, decl\n"},
           // Templates
           {R"cpp(
             namespace foo {
               template <typename $0^T>
               $1^T $2^x;
             }
           )cpp",
            "0: targets = {foo::T}, decl\n"
            "1: targets = {foo::T}\n"
            "2: targets = {foo::x}, decl\n"},
           // Templates
           {R"cpp(
             template<typename T> class vector {};
             namespace foo {
               template <typename $0^T>
               using $1^V = $2^vector<$3^T>;
             }
           )cpp",
            "0: targets = {foo::T}, decl\n"
            "1: targets = {foo::V}, decl\n"
            "2: targets = {vector}\n"
            "3: targets = {foo::T}\n"},
           // Concept
           {
               R"cpp(
               template <typename T>
               concept Drawable = requires (T t) { t.draw(); };
 
               namespace foo {
                 template <typename $0^T> requires $1^Drawable<$2^T>
                 void $3^bar($4^T $5^t) {
                   $6^t.$7^draw();
                 }
               }
           )cpp",
               "0: targets = {T}, decl\n"
               "1: targets = {Drawable}\n"
               "2: targets = {T}\n"
               "3: targets = {foo::bar}, decl\n"
               "4: targets = {T}\n"
               "5: targets = {t}, decl\n"
               "6: targets = {t}\n"
               "7: targets = {}\n"},
           // Objective-C: properties
           {
               R"cpp(
             @interface I {}
             @property(retain) I* x;
             @property(retain) I* y;
             @end
             I *f;
             void foo() {
               $0^f.$1^x.$2^y = 0;
             }
           )cpp",
               "0: targets = {f}\n"
               "1: targets = {I::x}\n"
               "2: targets = {I::y}\n"},
           // Objective-C: implicit properties
           {
               R"cpp(
             @interface I {}
             -(I*)x;
             -(void)setY:(I*)y;
             @end
             I *f;
             void foo() {
               $0^f.$1^x.$2^y = 0;
             }
           )cpp",
               "0: targets = {f}\n"
               "1: targets = {I::x}\n"
               "2: targets = {I::setY:}\n"},
           // Designated initializers.
           {R"cpp(
             void foo() {
               struct $0^Foo {
                 int $1^Bar;
               };
               $2^Foo $3^f { .$4^Bar = 42 };
             }
         )cpp",
            "0: targets = {Foo}, decl\n"
            "1: targets = {foo()::Foo::Bar}, decl\n"
            "2: targets = {Foo}\n"
            "3: targets = {f}, decl\n"
            "4: targets = {foo()::Foo::Bar}\n"},
           {R"cpp(
             void foo() {
               struct $0^Baz {
                 int $1^Field;
               };
               struct $2^Bar {
                 $3^Baz $4^Foo;
               };
               $5^Bar $6^bar { .$7^Foo.$8^Field = 42 };