[include-cleaner] Record concept uses

[sammccall]

Summary

Most cases handled by adding VisitConceptReference to RecursiveASTVisitor
though it is incomplete.

Fixes https://github.com/llvm/llvm-project/issues/60702

clang-tools-extra/include-cleaner/lib/WalkAST.cpp

public:
   }
   bool VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *VTSD) {
     if (VTSD->isExplicitSpecialization())
       report(VTSD->getLocation(),
              VTSD->getSpecializedTemplate()->getTemplatedDecl());
     return true;
   }
 
+  bool VisitConceptReference(const ConceptReference *CR) {
+    report(CR->getConceptNameLoc(), CR->getNamedConcept());
+    return true;
+  }
+
   // TypeLoc visitors.
   void reportType(SourceLocation RefLoc, NamedDecl *ND) {
     // Reporting explicit references to types nested inside classes can cause
     // issues, e.g. a type accessed through a derived class shouldn't require
     // inclusion of the base.
     // Hence we report all such references as implicit. The code must spell the
     // outer type-location somewhere, which will trigger an explicit reference
     // and per IWYS, it's that spelling's responsibility to bring in necessary
bool VisitTagTypeLoc(TagTypeLoc TTL) {
     return true;
   }
 
   bool VisitTypedefTypeLoc(TypedefTypeLoc TTL) {
     reportType(TTL.getNameLoc(), TTL.getTypedefNameDecl());
     return true;
   }
 
+  bool VisitAutoTypeLoc(AutoTypeLoc ATL) {
+    // FIXME: RAV should call VisitConceptReference here, but doesn't!
+    if (ATL.isConstrained())
+      report(ATL.getConceptNameLoc(), ATL.getNamedConcept());
+    return true;
+  }
+
   bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
     reportType(TL.getTemplateNameLoc(),
                getMostRelevantTemplatePattern(TL.getTypePtr()));
     return true;
   }
 
   bool VisitDeducedTemplateSpecializationTypeLoc(
       DeducedTemplateSpecializationTypeLoc TL) {

clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

std::vector<Decl::Kind> testWalk(llvm::StringRef TargetCode,
                                  llvm::StringRef ReferencingCode) {
   llvm::Annotations Target(TargetCode);
   llvm::Annotations Referencing(ReferencingCode);
 
   TestInputs Inputs(Referencing.code());
   Inputs.ExtraFiles["target.h"] = Target.code().str();
   Inputs.ExtraArgs.push_back("-include");
   Inputs.ExtraArgs.push_back("target.h");
-  Inputs.ExtraArgs.push_back("-std=c++17");
+  Inputs.ExtraArgs.push_back("-std=c++20");
   TestAST AST(Inputs);
   const auto &SM = AST.sourceManager();
 
   // We're only going to record references from the nominated point,
   // to the target file.
   FileID ReferencingFile = SM.getMainFileID();
   SourceLocation ReferencingLoc =
       SM.getComposedLoc(ReferencingFile, Referencing.point());

 }
 
 TEST(WalkAST, Enums) {
   testWalk("enum E { $explicit^A = 42, B = 43 };", "int e = ^A;");
   testWalk("enum class $explicit^E : int;", "enum class ^E : int {};");
   testWalk("enum class E : int {};", "enum class ^E : int ;");
 }
 
+TEST(WalkAST, Concepts) {
+  testWalk("template <class> concept $explicit^C = true;", "^C auto x = 1;");
+  testWalk("template <class> concept $explicit^C = true;", "bool x = ^C<int>;");
+  testWalk("template <class> concept $explicit^C = true;", "void X(^C auto);");
+  testWalk("template <class> concept $explicit^C = true;",
+           "template <^C T> int X;");
+  testWalk("template <class> concept $explicit^C = true;",
+           "template <^C auto T> int X;");
+  testWalk("template <class> concept $explicit^C = true;",
+           "template <class T> requires(^C<T>) int X;");
+}
+
 } // namespace
 } // namespace clang::include_cleaner

clang/include/clang/AST/RecursiveASTVisitor.h

 
 #define DEF_TRAVERSE_TMPL_INST(TMPLDECLKIND)                                   \
   bool TraverseTemplateInstantiations(TMPLDECLKIND##TemplateDecl *D);
   DEF_TRAVERSE_TMPL_INST(Class)
   DEF_TRAVERSE_TMPL_INST(Var)
   DEF_TRAVERSE_TMPL_INST(Function)
 #undef DEF_TRAVERSE_TMPL_INST
 
+  // FIXME: we should also provide VisitTypeConstraint.
+  // FIXME: VisitConceptReference is not yet called in constrained AutoTypeLoc.
+  bool VisitConceptReference(const ConceptReference *C) { return true; }
   bool TraverseTypeConstraint(const TypeConstraint *C);
 
   bool TraverseConceptRequirement(concepts::Requirement *R);
   bool TraverseConceptTypeRequirement(concepts::TypeRequirement *R);
   bool TraverseConceptExprRequirement(concepts::ExprRequirement *R);
   bool TraverseConceptNestedRequirement(concepts::NestedRequirement *R);
 
   bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue);
return getDerived().TraverseConceptNestedRequirement(
         cast<concepts::NestedRequirement>(R));
   }
   llvm_unreachable("unexpected case");
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseConceptReferenceHelper(
     const ConceptReference &C) {
+  TRY_TO(VisitConceptReference(&C));
   TRY_TO(TraverseNestedNameSpecifierLoc(C.getNestedNameSpecifierLoc()));
   TRY_TO(TraverseDeclarationNameInfo(C.getConceptNameInfo()));
   if (C.hasExplicitTemplateArgs())
     TRY_TO(TraverseTemplateArgumentLocsHelper(
         C.getTemplateArgsAsWritten()->getTemplateArgs(),
         C.getTemplateArgsAsWritten()->NumTemplateArgs));
   return true;
 }

 
 DEF_TRAVERSE_TYPELOC(UnaryTransformType, {
   TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));
 })
 
 DEF_TRAVERSE_TYPELOC(AutoType, {
   TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType()));
   if (TL.isConstrained()) {
+    // FIXME: should VisitConceptReference instead.
+    //        We don't store that node in the AST today.
     TRY_TO(TraverseNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc()));
     TRY_TO(TraverseDeclarationNameInfo(TL.getConceptNameInfo()));
     for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
       TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));
   }
 })
 
 DEF_TRAVERSE_TYPELOC(DeducedTemplateSpecializationType, {