[ASTDump] Mark variadic declarations with a tag instead of child node

[steveire]

Summary

This makes it easier to separate traversal of the AST from output
generation.

[aaron.ballman]

Can you add a test for a variadic lambda in C++ as well? I suspect it will work out of the box, but the extra test coverage would be good to have. We should probably have a K&R C function example as well to ensure it doesn't print as variadic. e.g., void func(); in C mode.

[aaron.ballman]

LGTM!

lib/AST/ASTDumper.cpp

public:
     }
     void VisitFunctionType(const FunctionType *T) {
       dumpTypeAsChild(T->getReturnType());
     }
     void VisitFunctionProtoType(const FunctionProtoType *T) {
       VisitFunctionType(T);
       for (QualType PT : T->getParamTypes())
         dumpTypeAsChild(PT);
-      if (T->getExtProtoInfo().Variadic)
-        dumpChild([=] { OS << "..."; });
     }
     void VisitTypeOfExprType(const TypeOfExprType *T) {
       dumpStmt(T->getUnderlyingExpr());
     }
     void VisitDecltypeType(const DecltypeType *T) {
       dumpStmt(T->getUnderlyingExpr());
     }
     void VisitUnaryTransformType(const UnaryTransformType *T) {

 void ASTDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
   if (D->isInstanceMethod())
     OS << " -";
   else
     OS << " +";
   NodeDumper.dumpName(D);
   NodeDumper.dumpType(D->getReturnType());
 
+  if (D->isVariadic())
+    OS << " variadic";
+
   if (D->isThisDeclarationADefinition()) {
     dumpDeclContext(D);
   } else {
     for (const ParmVarDecl *Parameter : D->parameters())
       dumpDecl(Parameter);
   }
 
-  if (D->isVariadic())
-    dumpChild([=] { OS << "..."; });
-
   if (D->hasBody())
     dumpStmt(D->getBody());
 }
 
 void ASTDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
   NodeDumper.dumpName(D);
   switch (D->getVariance()) {
   case ObjCTypeParamVariance::Invariant:
void ASTDumper::Visit(const BlockDecl::Capture &C) {
   dumpChild([=] {
     NodeDumper.Visit(C);
     if (C.hasCopyExpr())
       dumpStmt(C.getCopyExpr());
   });
 }
 
 void ASTDumper::VisitBlockDecl(const BlockDecl *D) {
+  if (D->isVariadic())
+    OS << " variadic";
+
   for (auto I : D->parameters())
     dumpDecl(I);
 
-  if (D->isVariadic())
-    dumpChild([=]{ OS << "..."; });
-
   if (D->capturesCXXThis())
     dumpChild([=]{ OS << "capture this"; });
 
   for (const auto &I : D->captures())
     Visit(I);
   dumpStmt(D->getBody());
 }
 

lib/AST/TextNodeDumper.cpp

void TextNodeDumper::VisitFunctionProtoType(const FunctionProtoType *T) {
   if (EPI.HasTrailingReturn)
     OS << " trailing_return";
   if (T->isConst())
     OS << " const";
   if (T->isVolatile())
     OS << " volatile";
   if (T->isRestrict())
     OS << " restrict";
+  if (T->getExtProtoInfo().Variadic)
+    OS << " variadic";
   switch (EPI.RefQualifier) {
   case RQ_None:
     break;
   case RQ_LValue:
     OS << " &";
     break;
   case RQ_RValue:
     OS << " &&";

test/AST/ast-dump-decl.m

 // CHECK-NEXT:   ObjCIvarDecl{{.*}} varPrivate 'int' private
 // CHECK-NEXT:   ObjCIvarDecl{{.*}} varProtected 'int' protected
 // CHECK-NEXT:   ObjCIvarDecl{{.*}} varPublic 'int' public
 // CHECK-NEXT:   ObjCIvarDecl{{.*}} varPackage 'int' package
 
 @interface testObjCMethodDecl : A {
 }
 - (int) TestObjCMethodDecl: (int)i, ...;
-// CHECK:      ObjCMethodDecl{{.*}} - TestObjCMethodDecl: 'int'
+// CHECK:      ObjCMethodDecl{{.*}} - TestObjCMethodDecl: 'int' variadic
 // CHECK-NEXT:   ParmVarDecl{{.*}} i 'int'
-// CHECK-NEXT:   ...
 @end
 
 @implementation testObjCMethodDecl
 - (int) TestObjCMethodDecl: (int)i, ... {
   return 0;
 }
-// CHECK:      ObjCMethodDecl{{.*}} - TestObjCMethodDecl: 'int'
+// CHECK:      ObjCMethodDecl{{.*}} - TestObjCMethodDecl: 'int' variadic
 // CHECK-NEXT:   ImplicitParamDecl{{.*}} self
 // CHECK-NEXT:   ImplicitParamDecl{{.*}} _cmd
 // CHECK-NEXT:   ParmVarDecl{{.*}} i 'int'
-// CHECK-NEXT:   ...
 // CHECK-NEXT:   CompoundStmt
 @end
 
 @protocol TestObjCProtocolDecl
 - (void) foo;
 @end
 // CHECK:      ObjCProtocolDecl{{.*}} TestObjCProtocolDecl
 // CHECK-NEXT:   ObjCMethodDecl{{.*}} foo

 // CHECK-NEXT:   ObjCPropertyImplDecl{{.*}} bar synthesize
 // CHECK-NEXT:     ObjCProperty{{.*}} 'bar'
 // CHECK-NEXT:     ObjCIvar{{.*}} 'bar' 'int'
 
 void TestBlockDecl(int x) {
   ^(int y, ...){ x; };
 }
 // CHECK:      FunctionDecl{{.*}}TestBlockDecl
-// CHECK:      BlockDecl
+// CHECK:      BlockDecl {{.+}} <col:3, col:21> col:3 variadic
 // CHECK-NEXT:   ParmVarDecl{{.*}} y 'int'
-// CHECK-NEXT:   ...
 // CHECK-NEXT:   capture ParmVar{{.*}} 'x' 'int'
 // CHECK-NEXT:   CompoundStmt
 
 @interface B
 + (int) foo;
 @end
 
 void f() {
   __typeof__(B.foo) Test;
 }
 // CHECK: VarDecl{{.*}}Test 'typeof (B.foo)':'int'