[clangd][c++20]Consider the constraint of a constrained auto in FindTarget.

[massberg]

Summary

This enables support of hover on concepts with auto types.

I'm not 100% sure if this is the correct fix, but it works for
the exmaples and in vscode.

[massberg]

clang-format code

[sammccall]

Sorry about the delay here.

Making the whole AutoTypeLoc resolve to the concept doesn't seem right - the auto part does not refer to the concept, and in principle refers to another type entirely.

Really I think there should be a child node representing just the concept part, probably a ConceptReference.

Compared to the case we discussed where constrained auto is a template type param, this looks easier: all the information is there in AutoTypeLoc.
I think we need RecursiveASTVisitor to assemble it into a ConceptReference, and (to use it with SelectionTree) we need the ability to store it in a DynTypedNode.

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

581

this is going to have the same behavior on the auto token, right?

This is my main practical concern, that go-to-definition, hover, find-refs, go-to-type etc on auto will now treat Fooable as their target.

(That said, I'm not sure exactly how common it is for auto to be constrained in a non-dependent context...)

[nridge]

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

581

That said, I'm not sure exactly how common it is for auto to be constrained in a non-dependent context...

I think it may be reasonably common. For example, in this hello world example for the C++23 asynchronous programming proposal we have things like scheduler auto and sender auto (where scheduler and sender are concepts).

So, do think we want auto linked to the concrete deduced type in situations like this, and only the concept name linked to the concept definition.

[nridge]

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

581

in this hello world example for the C++23 asynchronous programming proposal

(Slight correction: this is a C++26 proposal. My point remains though.)

[sammccall]

(This will look different/better after D155858, taking it off my radar until then)

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : public TypeVisitor<Visitor> {
         Outer.add(STTPT->getReplacementType(), Flags);
       }
       void VisitTemplateTypeParmType(const TemplateTypeParmType *TTPT) {
         Outer.add(TTPT->getDecl(), Flags);
       }
       void VisitObjCInterfaceType(const ObjCInterfaceType *OIT) {
         Outer.add(OIT->getDecl(), Flags);
       }
+      void VisitAutoType(const AutoType *T) {
+        if (T->isConstrained()) {
+          Outer.add(T->getTypeConstraintConcept(), Flags);
+        }
+        TypeVisitor<Visitor>::VisitAutoType(T);
+      }
     };
     Visitor(*this, Flags).Visit(T.getTypePtr());
   }
 
   void add(const NestedNameSpecifier *NNS, RelSet Flags) {
     if (!NNS)
       return;
     debug(*NNS, Flags);

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

Code = R"cpp(
     template <typename T, typename U>
     concept Fooable = true;
 
     template <[[Fooable]]<int> T>
     void bar(T t);
   )cpp";
   EXPECT_DECLS("ConceptSpecializationExpr",
                {"template <typename T, typename U> concept Fooable = true"});
+
+  // Constrained auto
+  Code = R"cpp(
+    template <typename T>
+    concept Fooable = true;
+
+    [[Fooable]] auto i = 42;
+  )cpp";
+  EXPECT_DECLS("AutoTypeLoc", {"template <typename T> concept Fooable = true"});
+
+  Code = R"cpp(
+    template <typename T>
+    concept Fooable = true;
+
+    template<[[Fooable]] auto x> void Foo() {}
+  )cpp";
+  EXPECT_DECLS("AutoTypeLoc", {"template <typename T> concept Fooable = true"});
 }
 
 TEST_F(TargetDeclTest, Coroutine) {
   Flags.push_back("-std=c++20");
 
   Code = R"cpp(
     namespace std {
     template <typename, typename...> struct coroutine_traits;

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";
        }},
+      // constraint of constrained auto
+      {R"cpp(
+        template <class T> concept Fooable = true;
+        [[Foo^able]] auto x = 1;
+        )cpp",
+       [](HoverInfo &HI) {
+         HI.NamespaceScope = "";
+         HI.Name = "Fooable";
+         HI.Kind = index::SymbolKind::Concept;
+         HI.Definition = "template <class T>\n"
+                         "concept Fooable = true";
+       }},
+      {R"cpp(
+        template <class T> concept Fooable = true;
+        template<[[Fooa^ble]] auto x> void Foo() {}
+        )cpp",
+       [](HoverInfo &HI) {
+         HI.NamespaceScope = "";
+         HI.Name = "Fooable";
+         HI.Kind = index::SymbolKind::Concept;
+         HI.Definition = "template <class T>\n"
+                         "concept Fooable = true";
+       }},
+      // concept
+      {R"cpp(
+        template <typename T>
+        concept Fooable = requires (T t) { t.foo(); };
+
+        template <typename T> requires [[Fo^oable]]<T>
+        void bar(T t) {
+          t.foo();
+        }
+        )cpp",
+       [](HoverInfo &HI) {
+         HI.NamespaceScope = "";
+         HI.Name = "Fooable";
+         HI.Kind = index::SymbolKind::Concept;
+         HI.Definition = "template <typename T>\n"
+                         "concept Fooable = requires(T t) { t.foo(); }";
+       }},
       // auto on lambda
       {R"cpp(
         void foo() {
           [[au^to]] lamb = []{};
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "auto";