[Concepts] Include the found concept decl when dumping the ConceptSpecializationExpr

[nridge]

clang/test/AST/ast-dump-concepts.cpp

18

nit: maybe check for the concept name as well?

[hokein]

address comment.

clang/include/clang/AST/TextNodeDumper.h

#include "clang/AST/AttrTextNodeDump.inc"
   void VisitObjCBoxedExpr(const ObjCBoxedExpr *Node);
   void VisitObjCSelectorExpr(const ObjCSelectorExpr *Node);
   void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node);
   void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node);
   void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node);
   void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node);
   void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node);
   void VisitOMPIteratorExpr(const OMPIteratorExpr *Node);
+  void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *Node);
 
   void VisitRValueReferenceType(const ReferenceType *T);
   void VisitArrayType(const ArrayType *T);
   void VisitConstantArrayType(const ConstantArrayType *T);
   void VisitVariableArrayType(const VariableArrayType *T);
   void VisitDependentSizedArrayType(const DependentSizedArrayType *T);
   void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T);
   void VisitVectorType(const VectorType *T);

clang/lib/AST/TextNodeDumper.cpp

for (unsigned I = 0, E = Node->numOfIterators(); I < E; ++I) {
     Visit(Range.End);
     if (Range.Step) {
       OS << " step ";
       Visit(Range.Step);
     }
   }
 }
 
+void TextNodeDumper::VisitConceptSpecializationExpr(
+    const ConceptSpecializationExpr *Node) {
+  OS << " ";
+  dumpBareDeclRef(Node->getFoundDecl());
+}
+
 void TextNodeDumper::VisitRValueReferenceType(const ReferenceType *T) {
   if (T->isSpelledAsLValue())
     OS << " written as lvalue reference";
 }
 
 void TextNodeDumper::VisitArrayType(const ArrayType *T) {
   switch (T->getSizeModifier()) {
   case ArrayType::Normal:

clang/test/AST/ast-dump-concepts.cpp

 concept unary_concept = true;
 
 template <typename T, typename U>
 concept binary_concept = true;
 
 template <typename T>
 struct Foo {
   // CHECK:      TemplateTypeParmDecl {{.*}} referenced Concept {{.*}} 'binary_concept'
-  // CHECK-NEXT: |-ConceptSpecializationExpr {{.*}} <col:13, col:31> 'bool'
+  // CHECK-NEXT: |-ConceptSpecializationExpr {{.*}} <col:13, col:31> 'bool' Concept {{.*}}
   // CHECK-NEXT: `-TemplateArgument {{.*}} type 'int'
   template <binary_concept<int> R>
   Foo(R);
 
   // CHECK:      TemplateTypeParmDecl {{.*}} referenced Concept {{.*}} 'unary_concept'
   // CHECK-NEXT: `-ConceptSpecializationExpr {{.*}} <col:13> 'bool'
   template <unary_concept R>
   Foo(R);
 };