[Index] [clangd] Support for concept declarations and requires expressions

[ilya-biryukov]

Summary

Add support for concepts and requires expression in the clang index.
Genarate USRs for concepts.

Also how RecursiveASTVisitor handles return type requirement in
requires expressions. The new code unpacks the synthetic template parameter
list used for storing the actual expression. This simplifies
implementation of the indexing. No code seems to depend on the original
traversal anyway and the synthesized template parameter list is easily
accessible from inside the requires expression if needed.

Add tests in the clangd codebase.

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

[sammccall]

This looks great!

Only thing I'm uncomfortable with is the lack of test coverage outside clangd.
I think the most valuable thing would be to have some direct testing of how RecursiveASTVisitor behaves.
Do you think you could add something to unittests/Tooling/RecursiveASTVisitorTests/Concept.cpp at least for your change and if there are any other bits that seem critical & missing?

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

3577

maybe also a constrained auto usage?

3584

I think it'd be useful to assert the presence/absence of template brackets/placeholders here, even if the behavior is not ideal today (in which case, comment to that effect).

Similarly it's probably worth having a concept B with two type params as these are different cases for template brackets when used as type (even if the behavior is the same)

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

1851

nit: does anything break if we just set c++20 unconditionally?

2080

maybe = 'c' and use char below? Don't make me think :-)

[ilya-biryukov]

In D124441#3474123, @sammccall wrote:

This looks great!

Only thing I'm uncomfortable with is the lack of test coverage outside clangd.
I think the most valuable thing would be to have some direct testing of how RecursiveASTVisitor behaves.

Just to be clear, I feel it is not RecursiveASTVisitor that's at fault here. It's rather design of the Index library that splits work into multiple visitors.
Requires expression is produces a template parameter list that suddenly appears out of nowhere in the BodyVisitor, whereas the code to handle it is in the DeclVisitor.

Do you think you could add something to unittests/Tooling/RecursiveASTVisitorTests/Concept.cpp at least for your change and if there are any other bits that seem critical & missing?

I actually think neither way to do the traversal works in all cases, so I'm reluctant to add a test, which feels like picking which behavior is better.
The change I have avoids code duplication in the index library and is probably more convenient for source tooling in general.
However, any code that needs to examine all elements of the AST for whatever reason (e.g. dumps or serialization) would probably be better off walking the synthesized template parameter list.
The idea is: it's not important how exactly we traverse the nodes there as long as all interested visitors get callbacks for nodes they're looking into.

The proper refactoring here would be to add Traverse and Visit methods for concept::Requirement and one for ExprRequirement::ReturnRequirement. Overriding VisitReturnRequirement in BodyVisitor would be enough and we can still visit the template parameter list like before.
I'd like to do this in a separate change, would that work for you?

[ilya-biryukov]

• Check 'Concept auto' completion,
• set -std=c++20 unconditionally,
• use char instead of int.

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

3584

The problem is that we currently add the template brackets everywhere.
I forgot to mention that I didn't solve this issue yet, it requires adding a new completion context and seems like a good independent change.

I've been collecting missing cases in the github issue, will make a note there.

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

1851

Yeah, good point. Other tests don't depend on it.

2080

Done. Just to make sure we're safe against new architectures for the next 250 years of C++ history.

[ilya-biryukov]

• clang-format the code

clang-tools-extra/clangd/CodeComplete.cpp

CompletionItemKind toCompletionItemKind(index::SymbolKind Kind) {
   case SK::ClassProperty:
   case SK::StaticProperty:
     return CompletionItemKind::Property;
   case SK::Constructor:
     return CompletionItemKind::Constructor;
   case SK::TemplateTypeParm:
   case SK::TemplateTemplateParm:
     return CompletionItemKind::TypeParameter;
+  case SK::Concept:
+    return CompletionItemKind::Interface;
   }
   llvm_unreachable("Unhandled clang::index::SymbolKind.");
 }
 
 CompletionItemKind
 toCompletionItemKind(CodeCompletionResult::ResultKind ResKind,
                      const NamedDecl *Decl,
                      CodeCompletionContext::Kind CtxKind) {

clang-tools-extra/clangd/Protocol.cpp

SymbolKind indexSymbolKindToSymbolKind(index::SymbolKind Kind) {
   case index::SymbolKind::Parameter:
   case index::SymbolKind::NonTypeTemplateParm:
     return SymbolKind::Variable;
   case index::SymbolKind::Using:
     return SymbolKind::Namespace;
   case index::SymbolKind::TemplateTemplateParm:
   case index::SymbolKind::TemplateTypeParm:
     return SymbolKind::TypeParameter;
+  case index::SymbolKind::Concept:
+    return SymbolKind::Interface;
   }
   llvm_unreachable("invalid symbol kind");
 }
 
 bool fromJSON(const llvm::json::Value &Params, ClientCapabilities &R,
               llvm::json::Path P) {
   const llvm::json::Object *O = Params.getAsObject();
   if (!O) {

clang-tools-extra/clangd/Quality.cpp

categorize(const index::SymbolInfo &D) {
   case index::SymbolKind::Struct:
   case index::SymbolKind::Class:
   case index::SymbolKind::Protocol:
   case index::SymbolKind::Extension:
   case index::SymbolKind::Union:
   case index::SymbolKind::TypeAlias:
   case index::SymbolKind::TemplateTypeParm:
   case index::SymbolKind::TemplateTemplateParm:
+  case index::SymbolKind::Concept:
     return SymbolQualitySignals::Type;
   case index::SymbolKind::Function:
   case index::SymbolKind::ClassMethod:
   case index::SymbolKind::InstanceMethod:
   case index::SymbolKind::StaticMethod:
   case index::SymbolKind::InstanceProperty:
   case index::SymbolKind::ClassProperty:
   case index::SymbolKind::StaticProperty:

clang-tools-extra/clangd/index/SymbolCollector.cpp

bool shouldCollectIncludePath(index::SymbolKind Kind) {
   case SK::Struct:
   case SK::Class:
   case SK::Union:
   case SK::TypeAlias:
   case SK::Using:
   case SK::Function:
   case SK::Variable:
   case SK::EnumConstant:
+  case SK::Concept:
     return true;
   default:
     return false;
   }
 }
 
 // Return the symbol range of the token at \p TokLoc.
 std::pair<SymbolLocation::Position, SymbolLocation::Position>

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

EXPECT_THAT(completions(Code + "fun(/*  ^", {}, Opts).Completions,
               UnorderedElementsAre(labeled("foo=")));
   EXPECT_THAT(completions(Code + "fun(/* f^", {}, Opts).Completions,
               UnorderedElementsAre(labeled("foo=")));
   EXPECT_THAT(completions(Code + "fun(/* x^", {}, Opts).Completions, IsEmpty());
   EXPECT_THAT(completions(Code + "fun(/* f ^", {}, Opts).Completions,
               IsEmpty());
 }
 
+TEST(CompletionTest, Concepts) {
+  Annotations Code(R"cpp(
+    template<class T>
+    concept A = sizeof(T) <= 8;
+
+    template<$tparam^A U>
+    int foo();
+
+    template<class T>
+    concept b = $expr^A<T> && $expr^sizeof(T) % 2 == 0 || $expr^A<T> && sizeof(T) == 1;
+  )cpp");
+  TestTU TU;
+  TU.Code = Code.code().str();
+  TU.ExtraArgs = {"-std=c++20"};
+
+  std::vector<Symbol> Syms = {conceptSym("same_as")};
+  for (auto P : Code.points("tparam")) {
+    ASSERT_THAT(completions(TU, P, Syms).Completions,
+                AllOf(Contains(named("A")), Contains(named("same_as")),
+                      Contains(named("class")), Contains(named("typename"))))
+        << "Completing template parameter at position " << P;
+  }
+
+  for (auto P : Code.points("expr")) {
+    EXPECT_THAT(completions(TU, P, Syms).Completions,
+                AllOf(Contains(named("A")), Contains(named("same_as"))))
+        << "Completing 'requires' expression at position " << P;
+  }
+}
+
 TEST(SignatureHelp, DocFormat) {
   Annotations Code(R"cpp(
     // Comment `with` markup.
     void foo(int);
     void bar() { foo(^); }
   )cpp");
   for (auto DocumentationFormat :
        {MarkupKind::PlainText, MarkupKind::Markdown}) {

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

 MATCHER_P(snippet, S, "") {
   return (arg.Name + arg.CompletionSnippetSuffix).str() == S;
 }
 MATCHER_P(qName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
 MATCHER_P(hasName, Name, "") { return arg.Name == Name; }
 MATCHER_P(templateArgs, TemplArgs, "") {
   return arg.TemplateSpecializationArgs == TemplArgs;
 }
+MATCHER_P(hasKind, Kind, "") { return arg.SymInfo.Kind == Kind; }
 MATCHER_P(declURI, P, "") {
   return StringRef(arg.CanonicalDeclaration.FileURI) == P;
 }
 MATCHER_P(defURI, P, "") { return StringRef(arg.Definition.FileURI) == P; }
 MATCHER(includeHeader, "") { return !arg.IncludeHeaders.empty(); }
 MATCHER_P(includeHeader, P, "") {
   return (arg.IncludeHeaders.size() == 1) &&
          (arg.IncludeHeaders.begin()->IncludeHeader == P);
TEST_F(SymbolCollectorTest, Reserved) {
   EXPECT_THAT(Symbols, UnorderedElementsAre(qName("__foo"), qName("_X"),
                                             qName("_X::secret")));
 
   CollectorOpts.CollectReserved = false;
   runSymbolCollector("", Header); //
   EXPECT_THAT(Symbols, IsEmpty());
 }
 
+TEST_F(SymbolCollectorTest, Concepts) {
+  const char *Header = R"cpp(
+    template <class T>
+    concept A = sizeof(T) <= 8;
+  )cpp";
+  runSymbolCollector("", Header, {"-std=c++20"});
+  EXPECT_THAT(Symbols,
+              UnorderedElementsAre(AllOf(
+                  qName("A"), hasKind(clang::index::SymbolKind::Concept))));
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/TestIndex.h

 // Creates a class symbol.
 Symbol cls(llvm::StringRef Name);
 // Creates an enum symbol.
 Symbol enm(llvm::StringRef Name);
 // Creates a variable symbol.
 Symbol var(llvm::StringRef Name);
 // Creates a namespace symbol.
 Symbol ns(llvm::StringRef Name);
+// Create a C++20 concept symbol.
+Symbol conceptSym(llvm::StringRef Name);
 
 // Create a slab of symbols with the given qualified names as IDs and names.
 SymbolSlab generateSymbols(std::vector<std::string> QualifiedNames);
 
 // Create a slab of symbols with IDs and names [Begin, End].
 SymbolSlab generateNumSymbols(int Begin, int End);
 
 // Returns fully-qualified name out of given symbol.

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

 Symbol var(llvm::StringRef Name) {
   return sym(Name, index::SymbolKind::Variable, "@\\0");
 }
 
 Symbol ns(llvm::StringRef Name) {
   return sym(Name, index::SymbolKind::Namespace, "@N@\\0");
 }
 
+Symbol conceptSym(llvm::StringRef Name) {
+  return sym(Name, index::SymbolKind::Concept, "@CT@\\0");
+}
+
 SymbolSlab generateSymbols(std::vector<std::string> QualifiedNames) {
   SymbolSlab::Builder Slab;
   for (llvm::StringRef QName : QualifiedNames)
     Slab.insert(symbol(QName));
   return std::move(Slab).build();
 }
 
 SymbolSlab generateNumSymbols(int Begin, int End) {

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

for (const llvm::StringRef Case : {
     ParsedAST AST = TU.build();
 
     EXPECT_THAT(findType(AST, A.point()),
                 Not(Contains(sym("Target", HeaderA.range(), HeaderA.range()))))
         << Case;
   }
 }
 
-void checkFindRefs(llvm::StringRef Test, bool UseIndex = false) {
+void checkFindRefs(llvm::StringRef Test, bool UseIndex = false,
+                   std::vector<std::string> ExtraArgs = {}) {
   Annotations T(Test);
   auto TU = TestTU::withCode(T.code());
+  TU.ExtraArgs = ExtraArgs;
+
   auto AST = TU.build();
   std::vector<Matcher<ReferencesResult::Reference>> ExpectedLocations;
   for (const auto &R : T.ranges())
     ExpectedLocations.push_back(AllOf(rangeIs(R), attrsAre(0u)));
   // $def is actually shorthand for both definition and declaration.
   // If we have cases that are definition-only, we should change this.
   for (const auto &R : T.ranges("def"))
     ExpectedLocations.push_back(
const char *Tests[] = {
         using $def[[MyTypeD^ef]] = int;
         enum MyEnum : [[MyTy^peDef]] { };
       )cpp",
   };
   for (const char *Test : Tests)
     checkFindRefs(Test);
 }
 
+TEST(FindReferences, ConceptsWithinAST) {
+  constexpr llvm::StringLiteral Code = R"cpp(
+    template <class T>
+    concept $def[[IsSmal^l]] = sizeof(T) <= 8;
+
+    template <class T>
+    concept IsSmallPtr = requires(T x) {
+      { *x } -> [[IsSmal^l]];
+    };
+
+    [[IsSmall]] auto i = 8;
+    template<[[IsSmal^l]] U> void foo();
+    template<class U> void bar() requires [[IsSmal^l]]<U>;
+    template<class U> requires [[IsSmal^l]]<U> void baz();
+    static_assert([[IsSma^ll]]<int>);
+  )cpp";
+  checkFindRefs(Code, false, {"-std=c++20"});
+}
+
+TEST(FindReferences, RequiresExprParameters) {
+  constexpr llvm::StringLiteral Code = R"cpp(
+    template <class T>
+    concept IsSmall = sizeof(T) <= 8;
+
+    template <class T>
+    concept IsSmallPtr = requires(T $def[[^x]]) {
+      { *[[^x]] } -> IsSmall;
+    };
+  )cpp";
+  checkFindRefs(Code, false, {"-std=c++20"});
+}
+
 TEST(FindReferences, IncludeOverrides) {
   llvm::StringRef Test =
       R"cpp(
         class Base {
         public:
           virtu^al void $decl[[f^unc]]() ^= ^0;
         };
         class Derived : public Base {

clang/include/clang/AST/RecursiveASTVisitor.h

DEF_TRAVERSE_STMT(RequiresExpr, {
   for (concepts::Requirement *Req : S->getRequirements())
     if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req)) {
       if (!TypeReq->isSubstitutionFailure())
         TRY_TO(TraverseTypeLoc(TypeReq->getType()->getTypeLoc()));
     } else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req)) {
       if (!ExprReq->isExprSubstitutionFailure())
         TRY_TO(TraverseStmt(ExprReq->getExpr()));
       auto &RetReq = ExprReq->getReturnTypeRequirement();
-      if (RetReq.isTypeConstraint())
-        TRY_TO(TraverseTemplateParameterListHelper(
-                   RetReq.getTypeConstraintTemplateParameterList()));
+      if (RetReq.isTypeConstraint()) {
+        TRY_TO(TraverseStmt(
+            RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()));
+      }
     } else {
       auto *NestedReq = cast<concepts::NestedRequirement>(Req);
       if (!NestedReq->isSubstitutionFailure())
         TRY_TO(TraverseStmt(NestedReq->getConstraintExpr()));
     }
 })
 
 // These literals (all of them) do not need any action.

clang/include/clang/Index/IndexSymbol.h

enum class SymbolKind : uint8_t {
   Destructor,
   ConversionFunction,
 
   Parameter,
   Using,
   TemplateTypeParm,
   TemplateTemplateParm,
   NonTypeTemplateParm,
+
+  Concept, /// C++20 concept.
 };
 
 enum class SymbolLanguage : uint8_t {
   C,
   ObjC,
   CXX,
   Swift,
 };

clang/lib/Index/IndexBody.cpp

 //===- IndexBody.cpp - Indexing statements --------------------------------===//
 //
 // 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 "IndexingContext.h"
-#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/ASTConcept.h"
 #include "clang/AST/ASTLambda.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/ExprConcepts.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/Type.h"
 
 using namespace clang;
 using namespace clang::index;
 
 namespace {
 
 class BodyIndexer : public RecursiveASTVisitor<BodyIndexer> {
   IndexingContext &IndexCtx;
for (unsigned I = 0, E = S->getNumComponents(); I != E; ++I) {
         IndexCtx.handleReference(Component.getField(), Component.getEndLoc(),
                                  Parent, ParentDC, SymbolRoleSet(), {});
       // FIXME: Try to resolve dependent field references.
     }
     return true;
   }
 
   bool VisitParmVarDecl(ParmVarDecl* D) {
-    // Index the parameters of lambda expression.
+    // Index the parameters of lambda expression and requires expression.
     if (IndexCtx.shouldIndexFunctionLocalSymbols()) {
       const auto *DC = D->getDeclContext();
-      if (DC && isLambdaCallOperator(DC))
+      if (DC && (isLambdaCallOperator(DC) || isa<RequiresExprBodyDecl>(DC)))
         IndexCtx.handleDecl(D);
     }
     return true;
   }
 
   bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
     SmallVector<SymbolRelation, 4> Relations;
     SymbolRoleSet Roles = getRolesForRef(E, Relations);
     for (auto *D : E->decls())
       IndexCtx.handleReference(D, E->getNameLoc(), Parent, ParentDC, Roles,
                                Relations, E);
     return true;
   }
+
+  bool VisitConceptSpecializationExpr(ConceptSpecializationExpr *R) {
+    IndexCtx.handleReference(R->getNamedConcept(), R->getConceptNameLoc(),
+                             Parent, ParentDC);
+    return true;
+  }
+
+  bool VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
+    // This handles references in return type requirements of RequiresExpr.
+    // E.g. `requires (T x) { {*x} -> ConceptRef }`
+    if (auto *C = D->getTypeConstraint())
+      IndexCtx.handleReference(C->getNamedConcept(), C->getConceptNameLoc(),
+                               Parent, ParentDC);
+    return true;
+  }
 };
 
 } // anonymous namespace
 
 void IndexingContext::indexBody(const Stmt *S, const NamedDecl *Parent,
                                 const DeclContext *DC) {
   if (!S)
     return;
 
   if (!DC)
     DC = Parent->getLexicalDeclContext();
   BodyIndexer(*this, Parent, DC).TraverseStmt(const_cast<Stmt*>(S));
 }

clang/lib/Index/IndexDecl.cpp

 //===- IndexDecl.cpp - Indexing declarations ------------------------------===//
 //
 // 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 "IndexingContext.h"
+#include "clang/AST/ASTConcept.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclVisitor.h"
 #include "clang/Index/IndexDataConsumer.h"
+#include "clang/Index/IndexSymbol.h"
 
 using namespace clang;
 using namespace index;
 
 #define TRY_DECL(D,CALL_EXPR)                                                  \
   do {                                                                         \
     if (!IndexCtx.shouldIndex(D)) return true;                                 \
     if (!CALL_EXPR)                                                            \
if (IndexCtx.shouldIndexFunctionLocalSymbols()) {
       if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
         if (FD->isThisDeclarationADefinition()) {
           for (const auto *PV : FD->parameters()) {
             IndexDefaultParmeterArgument(PV, D);
           }
         }
       }
     }
+    if (auto *C = D->getTrailingRequiresClause())
+      IndexCtx.indexBody(C, Parent);
   }
 
   bool handleObjCMethod(const ObjCMethodDecl *D,
                         const ObjCPropertyDecl *AssociatedProp = nullptr) {
     SmallVector<SymbolRelation, 4> Relations;
     SmallVector<const ObjCMethodDecl*, 4> Overriden;
 
     D->getOverriddenMethods(Overriden);
if (const auto *FD = dyn_cast<FunctionDecl>(D))
       return FD->getCanonicalDecl() == FD;
     else if (const auto *TD = dyn_cast<TagDecl>(D))
       return TD->getCanonicalDecl() == TD;
     else if (const auto *VD = dyn_cast<VarDecl>(D))
       return VD->getCanonicalDecl() == VD;
     return true;
   }
 
-  bool VisitTemplateDecl(const TemplateDecl *D) {
-
-    const NamedDecl *Parent = D->getTemplatedDecl();
-    if (!Parent)
-      return true;
-
-    // Index the default values for the template parameters.
-    if (D->getTemplateParameters() &&
-        shouldIndexTemplateParameterDefaultValue(Parent)) {
-      const TemplateParameterList *Params = D->getTemplateParameters();
-      for (const NamedDecl *TP : *Params) {
-        if (IndexCtx.shouldIndexTemplateParameters())
-          IndexCtx.handleDecl(TP);
-        if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(TP)) {
-          if (TTP->hasDefaultArgument())
-            IndexCtx.indexTypeSourceInfo(TTP->getDefaultArgumentInfo(), Parent);
-        } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(TP)) {
-          if (NTTP->hasDefaultArgument())
-            IndexCtx.indexBody(NTTP->getDefaultArgument(), Parent);
-        } else if (const auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(TP)) {
-          if (TTPD->hasDefaultArgument())
-            handleTemplateArgumentLoc(TTPD->getDefaultArgument(), Parent,
-                                      TP->getLexicalDeclContext());
-        }
-      }
+  void indexTemplateParameters(TemplateParameterList *Params,
+                               const NamedDecl *Parent) {
+        if (auto *C = TTP->getTypeConstraint())
+          IndexCtx.handleReference(C->getNamedConcept(), C->getConceptNameLoc(),
+                                   Parent, TTP->getLexicalDeclContext());
+    if (auto *R = Params->getRequiresClause())
+      IndexCtx.indexBody(R, Parent);
+  }
+
+  bool VisitTemplateDecl(const TemplateDecl *D) {
+    const NamedDecl *Parent = D->getTemplatedDecl();
+    if (!Parent)
+      return true;
+
+    // Index the default values for the template parameters.
+    auto *Params = D->getTemplateParameters();
+    if (Params && shouldIndexTemplateParameterDefaultValue(Parent)) {
+      indexTemplateParameters(Params, Parent);
     }
 
     return Visit(Parent);
   }
 
+  bool VisitConceptDecl(const ConceptDecl *D) {
+    if (auto *Params = D->getTemplateParameters())
+      indexTemplateParameters(Params, D);
+    if (auto *E = D->getConstraintExpr())
+      IndexCtx.indexBody(E, D);
+    return IndexCtx.handleDecl(D);
+  }
+
   bool VisitFriendDecl(const FriendDecl *D) {
     if (auto ND = D->getFriendDecl()) {
       // FIXME: Ignore a class template in a dependent context, these are not
       // linked properly with their redeclarations, ending up with duplicate
       // USRs.
       // See comment "Friend templates are visible in fairly strange ways." in
       // SemaTemplate.cpp which precedes code that prevents the friend template
       // from becoming visible from the enclosing context.

clang/lib/Index/IndexSymbol.cpp

case Decl::TemplateTypeParm:
       Info.Kind = SymbolKind::TemplateTypeParm;
       break;
     case Decl::TemplateTemplateParm:
       Info.Kind = SymbolKind::TemplateTemplateParm;
       break;
     case Decl::NonTypeTemplateParm:
       Info.Kind = SymbolKind::NonTypeTemplateParm;
       break;
+    case Decl::Concept:
+      Info.Kind = SymbolKind::Concept;
+      break;
     // Other decls get the 'unknown' kind.
     default:
       break;
     }
   }
 
   if (Info.Kind == SymbolKind::Unknown)
     return Info;
StringRef index::getSymbolKindString(SymbolKind K) {
   case SymbolKind::Constructor: return "constructor";
   case SymbolKind::Destructor: return "destructor";
   case SymbolKind::ConversionFunction: return "conversion-func";
   case SymbolKind::Parameter: return "param";
   case SymbolKind::Using: return "using";
   case SymbolKind::TemplateTypeParm: return "template-type-param";
   case SymbolKind::TemplateTemplateParm: return "template-template-param";
   case SymbolKind::NonTypeTemplateParm: return "non-type-template-param";
+  case SymbolKind::Concept: return "concept";
   }
   llvm_unreachable("invalid symbol kind");
 }
 
 StringRef index::getSymbolSubKindString(SymbolSubKind K) {
   switch (K) {
   case SymbolSubKind::None: return "<none>";
   case SymbolSubKind::CXXCopyConstructor: return "cxx-copy-ctor";

clang/lib/Index/IndexTypeSourceInfo.cpp

 //===- IndexTypeSourceInfo.cpp - Indexing types ---------------------------===//
 //
 // 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 "IndexingContext.h"
+#include "clang/AST/ASTConcept.h"
+#include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/TypeLoc.h"
 #include "llvm/ADT/ScopeExit.h"
 
 using namespace clang;
 using namespace index;
 
 namespace {
 
 class TypeIndexer : public RecursiveASTVisitor<TypeIndexer> {
bool VisitTypedefTypeLoc(TypedefTypeLoc TL) {
     } else {
       TRY_TO(IndexCtx.handleReference(ND, Loc,
                                       Parent, ParentDC, SymbolRoleSet(),
                                       Relations));
     }
     return true;
   }
 
+  bool VisitAutoTypeLoc(AutoTypeLoc TL) {
+    if (auto *C = TL.getNamedConcept())
+      return IndexCtx.handleReference(C, TL.getConceptNameLoc(), Parent,
+                                      ParentDC);
+    return true;
+  }
+
   bool traverseParamVarHelper(ParmVarDecl *D) {
     TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
     if (D->getTypeSourceInfo())
       TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
     return true;
   }
 
   bool TraverseParmVarDecl(ParmVarDecl *D) {

clang/lib/Index/IndexingContext.cpp

bool IndexingContext::handleReference(const NamedDecl *D, SourceLocation Loc,
   if (!shouldIndexFunctionLocalSymbols() && isFunctionLocalSymbol(D))
     return true;
 
   if (!shouldIndexTemplateParameters() &&
       (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
        isa<TemplateTemplateParmDecl>(D))) {
     return true;
   }
-
   return handleDeclOccurrence(D, Loc, /*IsRef=*/true, Parent, Roles, Relations,
                               RefE, RefD, DC);
 }
 
 static void reportModuleReferences(const Module *Mod,
                                    ArrayRef<SourceLocation> IdLocs,
                                    const ImportDecl *ImportD,
                                    IndexDataConsumer &DataConsumer) {
static bool isDeclADefinition(const Decl *D, const DeclContext *ContainerDC, ASTContext &Ctx) {
   if (auto MD = dyn_cast<ObjCMethodDecl>(D))
     return MD->isThisDeclarationADefinition() || isa<ObjCImplDecl>(ContainerDC);
 
   if (isa<TypedefNameDecl>(D) ||
       isa<EnumConstantDecl>(D) ||
       isa<FieldDecl>(D) ||
       isa<MSPropertyDecl>(D) ||
       isa<ObjCImplDecl>(D) ||
-      isa<ObjCPropertyImplDecl>(D))
+      isa<ObjCPropertyImplDecl>(D) ||
+      isa<ConceptDecl>(D))
     return true;
 
   return false;
 }
 
 /// Whether the given NamedDecl should be skipped because it has no name.
 static bool shouldSkipNamelessDecl(const NamedDecl *ND) {
   return (ND->getDeclName().isEmpty() && !isa<TagDecl>(ND) &&

clang/lib/Index/USRGeneration.cpp

public:
   void VisitTypedefDecl(const TypedefDecl *D);
   void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D);
   void VisitVarDecl(const VarDecl *D);
   void VisitBindingDecl(const BindingDecl *D);
   void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D);
   void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D);
   void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D);
   void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D);
+  void VisitConceptDecl(const ConceptDecl *D);
 
   void VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
     IgnoreResults = true; // No USRs for linkage specs themselves.
   }
 
   void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
     IgnoreResults = true;
   }
void USRGenerator::VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D) {
   if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
     return;
   VisitDeclContext(D->getDeclContext());
   Out << "@UUT@";
   printQualifier(Out, D->getASTContext(), D->getQualifier());
   Out << D->getName(); // Simple name.
 }
 
-
+void USRGenerator::VisitConceptDecl(const ConceptDecl *D) {
+  if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
+    return;
+  VisitDeclContext(D->getDeclContext());
+  Out << "@CT@";
+  EmitDeclName(D);
+}
 
 //===----------------------------------------------------------------------===//
 // USR generation functions.
 //===----------------------------------------------------------------------===//
 
 static void combineClassAndCategoryExtContainers(StringRef ClsSymDefinedIn,
                                                  StringRef CatSymDefinedIn,
                                                  raw_ostream &OS) {

clang/tools/libclang/CXIndexDataConsumer.cpp

static CXIdxEntityKind getEntityKindFromSymbolKind(SymbolKind K, SymbolLanguage Lang) {
   case SymbolKind::Unknown:
   case SymbolKind::Module:
   case SymbolKind::Macro:
   case SymbolKind::ClassProperty:
   case SymbolKind::Using:
   case SymbolKind::TemplateTypeParm:
   case SymbolKind::TemplateTemplateParm:
   case SymbolKind::NonTypeTemplateParm:
+  case SymbolKind::Concept:
     return CXIdxEntity_Unexposed;
 
   case SymbolKind::Enum: return CXIdxEntity_Enum;
   case SymbolKind::Struct: return CXIdxEntity_Struct;
   case SymbolKind::Union: return CXIdxEntity_Union;
   case SymbolKind::TypeAlias:
     if (Lang == SymbolLanguage::CXX)
       return CXIdxEntity_CXXTypeAlias;