NFC: Implement GenericSelectionExpr::Association dump with Visitor

[aaron.ballman]

LGTM with a few small cosmetic changes.

lib/AST/ASTDumper.cpp

1463–1464

These can be combined into a single if statement.

1476–1477

You can change this to be a range-based for loop over the associations to clean it up even further. for (const auto *A = E->getAssocExprs())

[aaron.ballman]

lib/AST/ASTDumper.cpp

1476–1477

Ah, I see now that this is over the new Association objects, not the old Expr * objects. I'll add comments on the other review, but same guideline here.

include/clang/AST/TextNodeDumper.h

public:
   void Visit(const Decl *D);
 
   void Visit(const CXXCtorInitializer *Init);
 
   void Visit(const OMPClause *C);
 
   void Visit(const BlockDecl::Capture &C);
 
+  void Visit(const GenericSelectionExpr::Association &A);
+
   void dumpPointer(const void *Ptr);
   void dumpLocation(SourceLocation Loc);
   void dumpSourceRange(SourceRange R);
   void dumpBareType(QualType T, bool Desugar = true);
   void dumpType(QualType T);
   void dumpBareDeclRef(const Decl *D);
   void dumpName(const NamedDecl *ND);
   void dumpAccessSpecifier(AccessSpecifier AS);

lib/AST/ASTDumper.cpp

public:
     // OpenMP
     void Visit(const OMPClause *C);
     void VisitOMPExecutableDirective(const OMPExecutableDirective *Node);
 
     // Exprs
     void VisitInitListExpr(const InitListExpr *ILE);
     void VisitBlockExpr(const BlockExpr *Node);
     void VisitOpaqueValueExpr(const OpaqueValueExpr *Node);
+    void Visit(const GenericSelectionExpr::Association &A);
     void VisitGenericSelectionExpr(const GenericSelectionExpr *E);
 
     // C++
     void VisitLambdaExpr(const LambdaExpr *Node) {
       dumpDecl(Node->getLambdaClass());
     }
     void VisitSizeOfPackExpr(const SizeOfPackExpr *Node);
 
void ASTDumper::VisitBlockExpr(const BlockExpr *Node) {
   dumpDecl(Node->getBlockDecl());
 }
 
 void ASTDumper::VisitOpaqueValueExpr(const OpaqueValueExpr *Node) {
   if (Expr *Source = Node->getSourceExpr())
     dumpStmt(Source);
 }
 
+void ASTDumper::Visit(const GenericSelectionExpr::Association &A) {
+  dumpChild([=] {
+    NodeDumper.Visit(A);
+    const TypeSourceInfo *TSI = A.getTypeSourceInfo();
+    if (TSI)
+      dumpTypeAsChild(TSI->getType());
+    dumpStmt(A.getExpr());
+  });
+}
+
 void ASTDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
   if (E->isResultDependent())
     OS << " result_dependent";
   dumpStmt(E->getControllingExpr());
   dumpTypeAsChild(E->getControllingExpr()->getType()); // FIXME: remove
 
   for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
-    dumpChild([=] {
-      const auto Assoc = E->getAssociation(I);
-      const TypeSourceInfo *TSI = Assoc.getTypeSourceInfo();
-      if (TSI) {
-        OS << "case ";
-        NodeDumper.dumpType(TSI->getType());
-      } else {
-        OS << "default";
-      }
-
-      if (Assoc.IsSelected())
-        OS << " selected";
-
-      if (TSI)
-        dumpTypeAsChild(TSI->getType());
-      dumpStmt(Assoc.getExpr());
-    });
+    Visit(E->getAssociation(I));
   }
 }
 
 //===----------------------------------------------------------------------===//
 // C++ Expressions
 //===----------------------------------------------------------------------===//
 
 void ASTDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {

lib/AST/TextNodeDumper.cpp

OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
        << ClauseName.drop_front() << "Clause";
   }
   dumpPointer(C);
   dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
   if (C->isImplicit())
     OS << " <implicit>";
 }
 
+void TextNodeDumper::Visit(const GenericSelectionExpr::Association &A) {
+  const TypeSourceInfo *TSI = A.getTypeSourceInfo();
+  if (TSI) {
+    OS << "case ";
+    dumpType(TSI->getType());
+  } else {
+    OS << "default";
+  }
+
+  if (A.IsSelected())
+    OS << " selected";
+}
+
 void TextNodeDumper::dumpPointer(const void *Ptr) {
   ColorScope Color(OS, ShowColors, AddressColor);
   OS << ' ' << Ptr;
 }
 
 void TextNodeDumper::dumpLocation(SourceLocation Loc) {
   if (!SM)
     return;