[clangd] prototype: for singly-instantiated templates, examine the instantiation

[sammccall]

Summary

This prototype is crude and breaks things (e.g. including rename).
It has this behavior for all selections and nothing else.
A real version would use it for *some* selections (not rename!) and some other
traversals too (syntax highlighting).

It does allow hover/go-to-definition to work in cases like:

void callMeWithFoos(std::function<void(Foo)>);
...
callMeWithFoos([](auto &&x) {
  x.^bar(); // will jump to Foo::bar
});

as well as other cases handled in D119537

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : public TypeVisitor<Visitor> {
           // fallback: the (un-specialized) declaration from primary template.
           if (auto *TD = TST->getTemplateName().getAsTemplateDecl())
             Outer.add(TD->getTemplatedDecl(), Flags | Rel::TemplatePattern);
         }
       }
       void VisitTemplateTypeParmType(const TemplateTypeParmType *TTPT) {
         Outer.add(TTPT->getDecl(), Flags);
       }
+      void
+      VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *STTPT) {
+        Outer.add(STTPT->getReplacedParameter()->getDecl(), Flags | Rel::Alias);
+        Outer.add(STTPT->getReplacementType(), Flags | Rel::Underlying);
+      }
       void VisitObjCInterfaceType(const ObjCInterfaceType *OIT) {
         Outer.add(OIT->getDecl(), Flags);
       }
       void VisitObjCObjectType(const ObjCObjectType *OOT) {
         // Make all of the protocols targets since there's no child nodes for
         // protocols. This isn't needed for the base type, which *does* have a
         // child `ObjCInterfaceTypeLoc`. This structure is a hack, but it works
         // well for go-to-definition.

clang-tools-extra/clangd/Selection.cpp

 //
 // While traversing, we maintain a parent stack. As nodes pop off the stack,
 // we decide whether to keep them or not. To be kept, they must either be
 // selected or contain some nodes that are.
 //
 // For simple cases (not inside macros) we prune subtrees that don't intersect.
 class SelectionVisitor : public RecursiveASTVisitor<SelectionVisitor> {
 public:
+  bool shouldVisitSingleTemplateInstantiationInstead() const { return true; }
+
   // Runs the visitor to gather selected nodes and their ancestors.
   // If there is any selection, the root (TUDecl) is the first node.
   static std::deque<Node> collect(ASTContext &AST,
                                   const syntax::TokenBuffer &Tokens,
                                   const PrintingPolicy &PP, unsigned Begin,
                                   unsigned End, FileID File) {
     SelectionVisitor V(AST, Tokens, PP, Begin, End, File);
     V.TraverseAST(AST);

clang/include/clang/AST/RecursiveASTVisitor.h

 template <typename FirstMethodPtrTy, typename SecondMethodPtrTy>
 bool isSameMethod(FirstMethodPtrTy FirstMethodPtr,
                   SecondMethodPtrTy SecondMethodPtr) {
   return is_same_method_impl<has_same_member_pointer_type<
       FirstMethodPtrTy,
       SecondMethodPtrTy>::value>::isSameMethod(FirstMethodPtr, SecondMethodPtr);
 }
 
+// Paper over API difference between Function templates and others.
+template <typename TemplatedDeclTy>
+TemplateSpecializationKind getTemplateSpecializationKind(TemplatedDeclTy *TD) {
+  return TD->getSpecializationKind();
+}
+
+inline TemplateSpecializationKind
+getTemplateSpecializationKind(FunctionDecl *FD) {
+  return FD->getTemplateSpecializationKind();
+}
+
+template <typename TemplateTy>
+auto getTemplatedDecl(TemplateTy *D, bool SingleInstantiationInstead)
+    -> decltype(D->getTemplatedDecl()) {
+  if (SingleInstantiationInstead && llvm::size(D->specializations()) == 1) {
+    auto *Candidate = *D->spec_begin();
+    if (getTemplateSpecializationKind(Candidate) != TSK_ExplicitSpecialization)
+      return Candidate;
+  }
+  return D->getTemplatedDecl();
+}
+
 } // end namespace detail
 
 /// A class that does preorder or postorder
 /// depth-first traversal on the entire Clang AST and visits each node.
 ///
 /// This class performs three distinct tasks:
 ///   1. traverse the AST (i.e. go to each node);
 ///   2. at a given node, walk up the class hierarchy, starting from
public:
 
   /// Return a reference to the derived class.
   Derived &getDerived() { return *static_cast<Derived *>(this); }
 
   /// Return whether this visitor should recurse into
   /// template instantiations.
   bool shouldVisitTemplateInstantiations() const { return false; }
 
+  /// When encountering a singly-instantiated template definition,
+  /// should we walk the instantiated body instead of the template body?
+  /// Ignored if shouldVisitTemplateInstantiations() is true.
+  bool shouldVisitSingleTemplateInstantiationInstead() const { return false; }
+
   /// Return whether this visitor should recurse into the types of
   /// TypeLocs.
   bool shouldWalkTypesOfTypeLocs() const { return true; }
 
   /// Return whether this visitor should recurse into implicit
   /// code, e.g., implicit constructors and destructors.
   bool shouldVisitImplicitCode() const { return false; }
 
for (auto *FD : D->specializations()) {
     }
   }
 
   return true;
 }
 
 // This macro unifies the traversal of class, variable and function
 // template declarations.
-#define DEF_TRAVERSE_TMPL_DECL(TMPLDECLKIND)                                   \
-  DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateDecl, {                              \
-    TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));   \
-    TRY_TO(TraverseDecl(D->getTemplatedDecl()));                               \
+#define DEF_TRAVERSE_TMPL_DECL(TMPLDECLKIND)                                     \
+  DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateDecl, {                                \
+    TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));     \
+    TRY_TO(TraverseDecl(detail::getTemplatedDecl(                                \
+        D,                                                                       \
+        !getDerived().shouldVisitTemplateInstantiations() &&                     \
+            getDerived().shouldVisitSingleTemplateInstantiationInstead())));     \
                                                                                  \
-    /* By default, we do not traverse the instantiations of                    \
-       class templates since they do not appear in the user code. The          \
-       following code optionally traverses them.                               \
-                                                                               \
-       We only traverse the class instantiations when we see the canonical     \
-       declaration of the template, to ensure we only visit them once. */      \
-    if (getDerived().shouldVisitTemplateInstantiations() &&                    \
-        D == D->getCanonicalDecl())                                            \
-      TRY_TO(TraverseTemplateInstantiations(D));                               \
+    /* By default, we do not traverse the instantiations of                      \
+       class templates since they do not appear in the user code. The            \
+       following code optionally traverses them.                                 \
+                                                                               \ \
+       We only traverse the class instantiations when we see the canonical       \
+       declaration of the template, to ensure we only visit them once. */        \
+    if (getDerived().shouldVisitTemplateInstantiations() &&                      \
+        D == D->getCanonicalDecl())                                              \
+      TRY_TO(TraverseTemplateInstantiations(D));                                 \
                                                                                  \
-    /* Note that getInstantiatedFromMemberTemplate() is just a link            \
-       from a template instantiation back to the template from which           \
-       it was instantiated, and thus should not be traversed. */               \
+    /* Note that getInstantiatedFromMemberTemplate() is just a link              \
+       from a template instantiation back to the template from which             \
+       it was instantiated, and thus should not be traversed. */                 \
   })
 
 DEF_TRAVERSE_TMPL_DECL(Class)
 DEF_TRAVERSE_TMPL_DECL(Var)
 DEF_TRAVERSE_TMPL_DECL(Function)
 
 DEF_TRAVERSE_DECL(TemplateTemplateParmDecl, {
   // D is the "T" in something like
for (unsigned I = 0, N = S->capture_size(); I != N; ++I) {
     }
   }
 
   if (getDerived().shouldVisitImplicitCode()) {
     // The implicit model is simple: everything else is in the lambda class.
     TRY_TO(TraverseDecl(S->getLambdaClass()));
   } else {
     // We need to poke around to find the bits that might be explicitly written.
-    TypeLoc TL = S->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
+    FunctionDecl *CallOperator = S->getCallOperator();
+    if (FunctionTemplateDecl *CallTemplate = S->getDependentCallOperator()) {
+      CallOperator = detail::getTemplatedDecl(
+          CallTemplate,
+          !getDerived().shouldVisitTemplateInstantiations() &&
+              getDerived().shouldVisitSingleTemplateInstantiationInstead());
+    }
+    TypeLoc TL = CallOperator->getTypeSourceInfo()->getTypeLoc();
     FunctionProtoTypeLoc Proto = TL.getAsAdjusted<FunctionProtoTypeLoc>();
 
     TRY_TO(TraverseTemplateParameterListHelper(S->getTemplateParameterList()));
     if (S->hasExplicitParameters()) {
       // Visit parameters.
       for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I)
         TRY_TO(TraverseDecl(Proto.getParam(I)));
     }
 
     auto *T = Proto.getTypePtr();
     for (const auto &E : T->exceptions())
       TRY_TO(TraverseType(E));
 
     if (Expr *NE = T->getNoexceptExpr())
       TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(NE);
 
     if (S->hasExplicitResultType())
       TRY_TO(TraverseTypeLoc(Proto.getReturnLoc()));
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getTrailingRequiresClause());
 
-    TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getBody());
+    TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(CallOperator->getBody());
   }
   ShouldVisitChildren = false;
 })
 
 DEF_TRAVERSE_STMT(CXXUnresolvedConstructExpr, {
   // This is called for code like 'T()', where T is a template argument.
   TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
 })