[clang][clangd][c++20] Improve support of type constraints in TemplateTypeParms.

[massberg]

Summary

Consider type constraints of TemplateTypeParmDecls in FindTarget.
To this end TemplateTypeParmTypeLoc:getLocalSourceRange() now also includes
the whole constraint if there is any.

In clangd this enables that Hover now works for type constraints of auto function parameters and
template parameters.

[massberg]

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

562

This is now a TemplateTypeParmTypeLoc as we have extended TemplateTypeParmTypeLoc:getLocalSourceRange() to include the constraint. Might this be problematic?

clang/unittests/AST/SourceLocationTest.cpp

274

This range looks a bit to long. What I'm doing wrong?

[massberg]

clang/unittests/AST/SourceLocationTest.cpp

274

Arg, ok T is also a constrained template type parameter, but with this patch we consider the whole template type parameter as concept which is in this case wrong (but works for the constrained auto as function parameter).

clang-tools-extra/clangd/FindTarget.cpp

if (const TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(D)) {
       if (const auto *CID = IID->getClassInterface())
         if (const auto *DD = CID->getDefinition())
           if (!DD->isImplicitInterfaceDecl())
             D = DD;
     } else if (const ObjCCategoryImplDecl *CID =
                    dyn_cast<ObjCCategoryImplDecl>(D)) {
       // Treat ObjC{Category,CategoryImpl}Decl as if they were a decl/def pair.
       D = CID->getCategoryDecl();
+    } else if (const TemplateTypeParmDecl *TTPD =
+                   dyn_cast<TemplateTypeParmDecl>(D)) {
+      if (auto *TC = TTPD->getTypeConstraint()) {
+        D = TC->getNamedConcept();
+      }
     }
     if (!D)
       return;
 
     if (const Decl *Pat = getTemplatePattern(D)) {
       assert(Pat != D);
       add(Pat, Flags | Rel::TemplatePattern);
       // Now continue with the instantiation.

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

TEST_F(TargetDeclTest, Concept) {
   // constrained-parameter
   Code = R"cpp(
     template <typename T>
     concept Fooable = true;
 
     template <[[Fooable]] T>
     void bar(T t);
   )cpp";
-  EXPECT_DECLS("ConceptSpecializationExpr",
+  EXPECT_DECLS("TemplateTypeParmTypeLoc",
                {"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("TemplateTypeParmTypeLoc",
+               {"template <typename T, typename U> concept Fooable = true"});
+
+  // Constrained function parameter
+  Code = R"cpp(
+    template <typename T, typename U>
+    concept Fooable = true;
+
+    void Foo([[Fooable]]<int> auto t);
+  )cpp";
+  EXPECT_DECLS("TemplateTypeParmTypeLoc",
                {"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";
        }},
+      // constrained function parameter
+      {R"cpp(
+        template <class T> concept Fooable = true;
+        void Foo([[Fooa^ble]] auto x) {}
+        )cpp",
+       [](HoverInfo &HI) {
+         HI.NamespaceScope = "";
+         HI.Name = "Fooable";
+         HI.Kind = index::SymbolKind::Concept;
+         HI.Definition = "template <class T>\nconcept Fooable = true";
+       }},
+      // constrained template parameter
+      {R"cpp(
+        template <class T> concept Fooable = true;
+        template <[[Foo^able]] T>
+        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";
+       }},
       // auto on lambda
       {R"cpp(
         void foo() {
           [[au^to]] lamb = []{};
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "auto";
for (const auto &Case : Cases) {
     EXPECT_EQ(H->Value, Expected.Value);
   }
 }
 
 TEST(Hover, Providers) {
   struct {
     const char *Code;
     const std::function<void(HoverInfo &)> ExpectedBuilder;
-  } Cases[] = {{R"cpp(
-                  struct Foo {};                     
+  } Cases[] = {
+      {R"cpp(
+                  struct Foo {};
                   Foo F = Fo^o{};
                 )cpp",
-                [](HoverInfo &HI) { HI.Provider = ""; }},
-               {R"cpp(
-                  #include "foo.h"                   
+                  #include "foo.h"
                   Foo F = Fo^o{};
                 )cpp",
-                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
-               {R"cpp(
-                  #include "all.h"  
+                  #include "all.h"
                   Foo F = Fo^o{};
                 )cpp",
-                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
-               {R"cpp(
                   #define FOO 5
                   int F = ^FOO;
                 )cpp",
-                [](HoverInfo &HI) { HI.Provider = ""; }},
-               {R"cpp(
                   #include "foo.h"
                   int F = ^FOO;
                 )cpp",
-                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
-               {R"cpp(
                   #include "all.h"
                   int F = ^FOO;
                 )cpp",
-                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
-               {R"cpp(
-                  #include "foo.h"    
+                  #include "foo.h"
                   Foo A;
                   Foo B;
                   Foo C = A ^+ B;
                 )cpp",
-                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
-               // Hover selects the underlying decl of the using decl
-               {R"cpp(
                   #include "foo.h"
                   namespace ns {
                     using ::Foo;
                   }
                   ns::F^oo d;
                 )cpp",
-                [](HoverInfo &HI) { HI.Provider = "\"foo.h\""; }},
-                {R"cpp(
                   namespace foo {};
                   using namespace fo^o;
                 )cpp",
-                [](HoverInfo &HI) { HI.Provider = ""; }},
-                };
 
   for (const auto &Case : Cases) {
     Annotations Code{Case.Code};
     SCOPED_TRACE(Code.code());
 
     TestTU TU;
     TU.Filename = "foo.cpp";
     TU.Code = Code.code();

clang/include/clang/AST/TypeLoc.h

 
 /// Wrapper for template type parameters.
 class TemplateTypeParmTypeLoc :
     public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                      TemplateTypeParmTypeLoc,
                                      TemplateTypeParmType> {
 public:
   TemplateTypeParmDecl *getDecl() const { return getTypePtr()->getDecl(); }
+
+  SourceRange getLocalSourceRange() const;
 };
 
 struct ObjCTypeParamTypeLocInfo {
   SourceLocation NameLoc;
 };
 
 /// ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for
 /// protocol qualifiers are stored after Info.

clang/lib/AST/TypeLoc.cpp

 //===- TypeLoc.cpp - Type Source Info Wrapper -----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the TypeLoc subclasses implementations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/TypeLoc.h"
-#include "clang/AST/DeclTemplate.h"
+#include "clang/AST/ASTConcept.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/TypeLocVisitor.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
 #include "llvm/Support/ErrorHandling.h"

 } // namespace
 
 AutoTypeLoc TypeLoc::getContainedAutoTypeLoc() const {
   TypeLoc Res = GetContainedAutoTypeLocVisitor().Visit(*this);
   if (Res.isNull())
     return AutoTypeLoc();
   return Res.getAs<AutoTypeLoc>();
 }
+
+SourceRange TemplateTypeParmTypeLoc::getLocalSourceRange() const {
+  SourceRange SR =
+      InheritingConcreteTypeLoc<TypeSpecTypeLoc, TemplateTypeParmTypeLoc,
+                                TemplateTypeParmType>::getLocalSourceRange();
+  SourceLocation StartLoc = SR.getBegin();
+
+  if (auto *D = getDecl()) {
+    if (auto *TC = D->getTypeConstraint()) {
+      if (TC->getNestedNameSpecifierLoc()) {
+        StartLoc = TC->getNestedNameSpecifierLoc().getBeginLoc();
+      } else {
+        StartLoc = TC->getConceptNameLoc();
+      }
+    }
+  }
+  return SourceRange(StartLoc, getNameLoc());
+}

clang/unittests/AST/SourceLocationTest.cpp

 // rather than a unit test file for source locations for all AST nodes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MatchVerifier.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Testing/CommandLineArgs.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Testing/Annotations/Annotations.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace clang::ast_matchers;
 
 namespace {
const char *Code =
       R"cpp(template <typename T> concept C = true;
 C auto abc();
 )cpp";
   // Should include "C auto" tokens.
   Verifier.expectRange(2, 1, 2, 3); // token range.
   EXPECT_TRUE(Verifier.match(Code, typeLoc(loc(autoType())), Lang_CXX20));
 }
 
+TEST(TypeLoc, TemplateTypeParmTypeLocRange) {
+  RangeVerifier<TypeLoc> Verifier;
+  Verifier.expectRange(2, 10, 2, 18);
+  EXPECT_TRUE(Verifier.match("template <typename T> concept Fooable = true;\n"
+                             "void Bar(Fooable auto x) {}",
+                             typeLoc(loc(templateTypeParmType())), Lang_CXX20));
+
+  Verifier.expectRange(2, 11, 2, 31);
+  EXPECT_TRUE(Verifier.match("template <typename T> concept Fooable = true;\n"
+                             "template <Fooable T> void bar(T t) {}",
+                             typeLoc(loc(templateTypeParmType())), Lang_CXX20));
+}
+
 TEST(TypeLoc, LongDoubleRange) {
   RangeVerifier<TypeLoc> Verifier;
   Verifier.expectRange(1, 1, 1, 6);
   EXPECT_TRUE(Verifier.match("long double a;", typeLoc()));
 }
 
 TEST(TypeLoc, DoubleLongRange) {
   RangeVerifier<TypeLoc> Verifier;
TEST(CompoundLiteralExpr, CompoundVectorLiteralRange) {
   EXPECT_TRUE(Verifier.match(
                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
                   "int2 i2 = (int2){1, 2};", compoundLiteralExpr()));
 }
 
 TEST(CompoundLiteralExpr, ParensCompoundVectorLiteralRange) {
   RangeVerifier<CompoundLiteralExpr> Verifier;
   Verifier.expectRange(2, 20, 2, 31);
-  EXPECT_TRUE(Verifier.match(
-                  "typedef int int2 __attribute__((ext_vector_type(2)));\n"
-                  "constant int2 i2 = (int2)(1, 2);", 
+  EXPECT_TRUE(
+      Verifier.match("typedef int int2 __attribute__((ext_vector_type(2)));\n"
+                     "constant int2 i2 = (int2)(1, 2);",
                      compoundLiteralExpr(), Lang_OpenCL));
 }
 
 TEST(InitListExpr, VectorLiteralListBraceRange) {
   RangeVerifier<InitListExpr> Verifier;
   Verifier.expectRange(2, 17, 2, 22);
   EXPECT_TRUE(Verifier.match(
                   "typedef int int2 __attribute__((ext_vector_type(2)));\n"
                   "int2 i2 = (int2){1, 2};", initListExpr()));