[clangd] Support ConceptReference in generic AST wrangling code

[sammccall]

Summary

Now we can store it in DynTypedNode, we can target these nodes
(SelectionTree) and resolve them (FindTarget).
This makes Hover, go-to-def etc work in all(?) cases.

Also support it in DumpAST.

clang-tools-extra/clangd/DumpAST.cpp

#undef ATTR
     }
     llvm_unreachable("Unhandled attr::Kind enum");
   }
   std::string getKind(const CXXBaseSpecifier &CBS) {
     // There aren't really any variants of CXXBaseSpecifier.
     // To avoid special cases in the API/UI, use public/private as the kind.
     return getAccessSpelling(CBS.getAccessSpecifier()).str();
   }
+  std::string getKind(const ConceptReference *CR) {
+    // Again there are no variants here.
+    // Kind is "Concept", role is "reference"
+    return "Concept";
+  }
 
   // Detail is the single most important fact about the node.
   // Often this is the name, sometimes a "kind" enum like operators or casts.
   // We should avoid unbounded text, like dumping parameter lists.
 
   std::string getDetail(const Decl *D) {
     const auto *ND = dyn_cast<NamedDecl>(D);
     if (!ND || llvm::isa_and_nonnull<CXXConstructorDecl>(ND->getAsFunction()) ||
std::string getDetail(const TemplateName &TN) {
     });
   }
   std::string getDetail(const Attr *A) {
     return A->getAttrName() ? A->getNormalizedFullName() : A->getSpelling();
   }
   std::string getDetail(const CXXBaseSpecifier &CBS) {
     return CBS.isVirtual() ? "virtual" : "";
   }
+  std::string getDetail(const ConceptReference *CR) {
+    return CR->getNamedConcept()->getNameAsString();
+  }
 
   /// Arcana is produced by TextNodeDumper, for the types it supports.
 
   template <typename Dump> std::string dump(const Dump &D) {
     return toString([&](raw_ostream &OS) {
       TextNodeDumper Dumper(OS, Ctx, /*ShowColors=*/false);
       D(Dumper);
     });
public:
   bool TraverseConstructorInitializer(CXXCtorInitializer *CCI) {
     return !CCI || traverseNode("constructor initializer", CCI, [&] {
       Base::TraverseConstructorInitializer(CCI);
     });
   }
   bool TraverseAttr(Attr *A) {
     return !A || traverseNode("attribute", A, [&] { Base::TraverseAttr(A); });
   }
+  bool TraverseConceptReference(ConceptReference *C) {
+    return !C || traverseNode("reference", C,
+                              [&] { Base::TraverseConceptReference(C); });
+  }
   bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &CBS) {
     return traverseNode("base", CBS,
                         [&] { Base::TraverseCXXBaseSpecifier(CBS); });
   }
   // Stmt is the same, but this form allows the data recursion optimization.
   bool dataTraverseStmtPre(Stmt *S) {
     return S && traverseNodePre(isa<Expr>(S) ? "expression" : "statement", S);
   }
ASTNode dumpAST(const DynTypedNode &N, const syntax::TokenBuffer &Tokens,
   else if (const auto *QT = N.get<QualType>())
     V.TraverseType(*const_cast<QualType *>(QT));
   else if (const auto *CCI = N.get<CXXCtorInitializer>())
     V.TraverseConstructorInitializer(const_cast<CXXCtorInitializer *>(CCI));
   else if (const auto *TAL = N.get<TemplateArgumentLoc>())
     V.TraverseTemplateArgumentLoc(*const_cast<TemplateArgumentLoc *>(TAL));
   else if (const auto *CBS = N.get<CXXBaseSpecifier>())
     V.TraverseCXXBaseSpecifier(*const_cast<CXXBaseSpecifier *>(CBS));
+  else if (const auto *CR = N.get<ConceptReference>())
+    V.TraverseConceptReference(const_cast<ConceptReference *>(CR));
   else
     elog("dumpAST: unhandled DynTypedNode kind {0}",
          N.getNodeKind().asStringRef());
   return std::move(V.Root);
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/FindTarget.cpp

 //===--- FindTarget.cpp - What does an AST node refer to? -----------------===//
 //
 // 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 "FindTarget.h"
 #include "AST.h"
 #include "HeuristicResolver.h"
 #include "support/Logger.h"
+#include "clang/AST/ASTConcept.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclVisitor.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/Expr.h"
struct Visitor : public ConstStmtVisitor<Visitor> {
       TargetFinder &Outer;
       RelSet Flags;
       Visitor(TargetFinder &Outer, RelSet Flags) : Outer(Outer), Flags(Flags) {}
 
       void VisitCallExpr(const CallExpr *CE) {
         Outer.add(CE->getCalleeDecl(), Flags);
       }
       void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E) {
-        Outer.add(E->getNamedConcept(), Flags);
+        Outer.add(E->getConceptReference(), Flags);
       }
       void VisitDeclRefExpr(const DeclRefExpr *DRE) {
         const Decl *D = DRE->getDecl();
         // UsingShadowDecl allows us to record the UsingDecl.
         // getFoundDecl() returns the wrong thing in other cases (templates).
         if (auto *USD = llvm::dyn_cast<UsingShadowDecl>(DRE->getFoundDecl()))
           D = USD;
         Outer.add(D, Flags);
if (Arg.getKind() == TemplateArgument::Template ||
               Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl()) {
         report(TD, Flags);
       }
       if (const auto *USD =
               Arg.getAsTemplateOrTemplatePattern().getAsUsingShadowDecl())
         add(USD, Flags);
     }
   }
+
+  void add(const ConceptReference *CR, RelSet Flags) {
+    add(CR->getNamedConcept(), Flags);
+  }
 };
 
 } // namespace
 
 llvm::SmallVector<std::pair<const NamedDecl *, DeclRelationSet>, 1>
 allTargetDecls(const DynTypedNode &N, const HeuristicResolver *Resolver) {
   dlog("allTargetDecls({0})", nodeToString(N));
   TargetFinder Finder(Resolver);
allTargetDecls(const DynTypedNode &N, const HeuristicResolver *Resolver) {
   else if (const CXXCtorInitializer *CCI = N.get<CXXCtorInitializer>())
     Finder.add(CCI, Flags);
   else if (const TemplateArgumentLoc *TAL = N.get<TemplateArgumentLoc>())
     Finder.add(TAL->getArgument(), Flags);
   else if (const CXXBaseSpecifier *CBS = N.get<CXXBaseSpecifier>())
     Finder.add(CBS->getTypeSourceInfo()->getType(), Flags);
   else if (const ObjCProtocolLoc *PL = N.get<ObjCProtocolLoc>())
     Finder.add(PL->getProtocol(), Flags);
+  else if (const ConceptReference *CR = N.get<ConceptReference>())
+    Finder.add(CR, Flags);
   return Finder.takeDecls();
 }
 
 llvm::SmallVector<const NamedDecl *, 1>
 targetDecl(const DynTypedNode &N, DeclRelationSet Mask,
            const HeuristicResolver *Resolver) {
   llvm::SmallVector<const NamedDecl *, 1> Result;
   for (const auto &Entry : allTargetDecls(N, Resolver)) {
bool TraverseObjCProtocolLoc(ObjCProtocolLoc ProtocolLoc) {
     return true;
   }
 
   bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
     visitNode(DynTypedNode::create(*Init));
     return RecursiveASTVisitor::TraverseConstructorInitializer(Init);
   }
 
-  bool VisitConceptReference(ConceptReference *ConceptRef) {
-    Out(ReferenceLoc{ConceptRef->getNestedNameSpecifierLoc(),
-                     ConceptRef->getConceptNameLoc(),
-                     /*IsDecl=*/false,
-                     {ConceptRef->getNamedConcept()}});
+  bool VisitConceptReference(const ConceptReference *CR) {
+    visitNode(DynTypedNode::create(*CR));
     return true;
   }
 
 private:
   /// Obtain information about a reference directly defined in \p N. Does not
   /// recurse into child nodes, e.g. do not expect references for constructor
   /// initializers
   ///
if (const CXXCtorInitializer *CCI = N.get<CXXCtorInitializer>()) {
                              {CCI->getAnyMember()}}};
       }
     }
     if (const ObjCProtocolLoc *PL = N.get<ObjCProtocolLoc>())
       return {ReferenceLoc{NestedNameSpecifierLoc(),
                            PL->getLocation(),
                            /*IsDecl=*/false,
                            {PL->getProtocol()}}};
+    if (const ConceptReference *CR = N.get<ConceptReference>())
+      return {ReferenceLoc{CR->getNestedNameSpecifierLoc(),
+                           CR->getConceptNameLoc(),
+                           /*IsDecl=*/false,
+                           {CR->getNamedConcept()}}};
 
     // We do not have location information for other nodes (QualType, etc)
     return {};
   }
 
   void visitNode(DynTypedNode N) {
     for (auto &R : explicitReference(N))
       reportReference(std::move(R), N);

clang-tools-extra/clangd/Selection.cpp

public:
   //
   // Two categories of nodes are not "well-behaved":
   //  - those without source range information, we don't record those
   //  - those that can't be stored in DynTypedNode.
   bool TraverseDecl(Decl *X) {
     if (llvm::isa_and_nonnull<TranslationUnitDecl>(X))
       return Base::TraverseDecl(X); // Already pushed by constructor.
     // Base::TraverseDecl will suppress children, but not this node itself.
-    if (X && X->isImplicit())
-      return true;
+    if (X && X->isImplicit()) {
+      // Most implicit nodes have only implicit children and can be skipped.
+      // However there are exceptions (`void foo(Concept auto x)`), and
+      // the base implementation knows how to find them.
+      return Base::TraverseDecl(X);
+    }
     return traverseNode(X, [&] { return Base::TraverseDecl(X); });
   }
   bool TraverseTypeLoc(TypeLoc X) {
     return traverseNode(&X, [&] { return Base::TraverseTypeLoc(X); });
   }
   bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &X) {
     return traverseNode(&X,
                         [&] { return Base::TraverseTemplateArgumentLoc(X); });
   }
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc X) {
     return traverseNode(
         &X, [&] { return Base::TraverseNestedNameSpecifierLoc(X); });
   }
   bool TraverseConstructorInitializer(CXXCtorInitializer *X) {
     return traverseNode(
         X, [&] { return Base::TraverseConstructorInitializer(X); });
   }
   bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &X) {
     return traverseNode(&X, [&] { return Base::TraverseCXXBaseSpecifier(X); });
   }
   bool TraverseAttr(Attr *X) {
     return traverseNode(X, [&] { return Base::TraverseAttr(X); });
   }
+  bool TraverseConceptReference(ConceptReference *X) {
+    return traverseNode(X, [&] { return Base::TraverseConceptReference(X); });
+  }
   // Stmt is the same, but this form allows the data recursion optimization.
   bool dataTraverseStmtPre(Stmt *X) {
     if (!X || isImplicit(X))
       return false;
     auto N = DynTypedNode::create(*X);
     if (canSafelySkipNode(N))
       return false;
     push(std::move(N));

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

Code = R"cpp(
     concept Fooable = requires (T t) { t.foo(); };
 
     template <typename T> requires [[Fooable]]<T>
     void bar(T t) {
       t.foo();
     }
   )cpp";
   EXPECT_DECLS(
-      "ConceptSpecializationExpr",
+      "ConceptReference",
       {"template <typename T> concept Fooable = requires (T t) { t.foo(); }"});
 
   // trailing requires clause
   Code = R"cpp(
       template <typename T>
       concept Fooable = true;
 
       template <typename T>
       void foo() requires [[Fooable]]<T>;
   )cpp";
-  EXPECT_DECLS("ConceptSpecializationExpr",
+  EXPECT_DECLS("ConceptReference",
                {"template <typename T> concept Fooable = true"});
 
   // constrained-parameter
   Code = R"cpp(
     template <typename T>
     concept Fooable = true;
 
     template <[[Fooable]] T>
     void bar(T t);
   )cpp";
-  EXPECT_DECLS("ConceptSpecializationExpr",
+  EXPECT_DECLS("ConceptReference",
                {"template <typename T> concept Fooable = true"});
 
   // partial-concept-id
   Code = R"cpp(
     template <typename T, typename U>
     concept Fooable = true;
 
     template <[[Fooable]]<int> T>
     void bar(T t);
   )cpp";
-  EXPECT_DECLS("ConceptSpecializationExpr",
+  EXPECT_DECLS("ConceptReference",
                {"template <typename T, typename U> concept Fooable = true"});
 }
 
 TEST_F(TargetDeclTest, Coroutine) {
   Flags.push_back("-std=c++20");
 
   Code = R"cpp(
     namespace std {

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

class Foo final {})cpp";
         template <class T> concept F = true;
         F [[au^to]] x = 1;
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "auto";
          HI.Kind = index::SymbolKind::TypeAlias;
          HI.Definition = "int";
        }},
+      {R"cpp(
+        template <class T> concept F = true;
+        [[^F]] auto x = 1;
+        )cpp",
+       [](HoverInfo &HI) {
+         HI.NamespaceScope = "";
+         HI.Name = "F";
+         HI.Kind = index::SymbolKind::Concept;
+         HI.Definition = "template <class T>\nconcept F = true";
+       }},
       // auto on lambda
       {R"cpp(
         void foo() {
           [[au^to]] lamb = []{};
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "auto";
class Foo final {})cpp";
         void bar(T t) {}
         )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "Fooable";
          HI.Kind = index::SymbolKind::Concept;
          HI.Definition = "template <class T>\nconcept Fooable = true";
        }},
-       {R"cpp(
         template<class T> concept Fooable = true;
         template<Fooable [[T^T]]>
         void bar(TT t) {}
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "TT";
          HI.Type = "class";
          HI.AccessSpecifier = "public";
          HI.NamespaceScope = "";
          HI.LocalScope = "bar::";
          HI.Kind = index::SymbolKind::TemplateTypeParm;
          HI.Definition = "Fooable TT";
        }},
+      {R"cpp(
+        template<class T> concept Fooable = true;
+        void bar([[Foo^able]] auto t) {}
+        )cpp",
+       [](HoverInfo &HI) {
+         HI.NamespaceScope = "";
+         HI.Name = "Fooable";
+         HI.Kind = index::SymbolKind::Concept;
+         HI.Definition = "template <class T>\nconcept Fooable = true";
+       }},
+      // concept reference
+      {R"cpp(
+        template<class T> concept Fooable = true;
+        auto X = [[Fooa^ble]]<int>;
+        )cpp",
+       [](HoverInfo &HI) {
+         HI.NamespaceScope = "";
+         HI.Name = "Fooable";
+         HI.Kind = index::SymbolKind::Concept;
+         HI.Definition = "template <class T>\nconcept Fooable = true";
+         HI.Value = "true";
+       }},
 
       // empty macro
       {R"cpp(
         #define MACRO
         [[MAC^RO]]
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "MACRO";

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

Case Cases[] = {
         [[using ^enum ns::A]];
         )cpp",
        "UsingEnumDecl"},
       {R"cpp(
         namespace ns { enum class A {}; };
         [[^using enum ns::A]];
         )cpp",
        "UsingEnumDecl"},
+
+      // concepts
+      {R"cpp(
+        template <class> concept C = true;
+        auto x = [[^C<int>]];
+      )cpp",
+       "ConceptReference"},
+      {R"cpp(
+        template <class> concept C = true;
+        [[^C]] auto x = 0;
+      )cpp",
+       "ConceptReference"},
+      {R"cpp(
+        template <class> concept C = true;
+        void foo([[^C]] auto x) {}
+      )cpp",
+       "ConceptReference"},
+      {R"cpp(
+        template <class> concept C = true;
+        template <[[^C]] x> int i = 0;
+      )cpp",
+       "ConceptReference"},
+      {R"cpp(
+        namespace ns { template <class> concept C = true; }
+        auto x = [[ns::^C<int>]];
+      )cpp",
+       "ConceptReference"},
   };
 
   for (const Case &C : Cases) {
     trace::TestTracer Tracer;
     Annotations Test(C.Code);
 
     TestTU TU;
     TU.Code = std::string(Test.code());