Re-order content of template parameter dumps

[aaron.ballman]

test/AST/ast-dump-decl.cpp

330–331

This looks wrong to me. You did not inherit the TemplateTypeParmDecl from above, you inherited the TemplateArgument. The order is important here and should be preserved to avoid confusion.

[steveire]

test/AST/ast-dump-decl.cpp

330–331

Should this be dumped as a child of the TemplateArgument then? I can add it as a child in ASTDumper::dumpTemplateArgument.

[aaron.ballman]

test/AST/ast-dump-decl.cpp

330–331

I kind of think it should. We follow the same pattern in each place -- print the template argument, then print this information, so combining it seems reasonable to me.

[steveire]

New approach

[aaron.ballman]

LGTM aside from some minor nits

lib/AST/ASTDumper.cpp

106

s/label/Label per naming conventions (same below).

730

Elide braces.

lib/AST/ASTDumper.cpp

public:
     void dumpAttr(const Attr *A);
 
     // C++ Utilities
     void dumpCXXCtorInitializer(const CXXCtorInitializer *Init);
     void dumpTemplateParameters(const TemplateParameterList *TPL);
     void dumpTemplateArgumentListInfo(const TemplateArgumentListInfo &TALI);
     void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A);
     void dumpTemplateArgumentList(const TemplateArgumentList &TAL);
     void dumpTemplateArgument(const TemplateArgument &A,
                               SourceRange R = SourceRange());
 
     // Objective-C utilities.
     void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams);
 
     // Types
     void VisitComplexType(const ComplexType *T) {
       dumpTypeAsChild(T->getElementType());

 }
 
 void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R) {
   dumpChild([=] {
     OS << "TemplateArgument";
     if (R.isValid())
       NodeDumper.dumpSourceRange(R);
 
     switch (A.getKind()) {
     case TemplateArgument::Null:
       OS << " null";
       break;
     case TemplateArgument::Type:
       OS << " type";
       NodeDumper.dumpType(A.getAsType());
       break;
     case TemplateArgument::Declaration:
void ASTDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
   if (D->wasDeclaredWithTypename())
     OS << " typename";
   else
     OS << " class";
   OS << " depth " << D->getDepth() << " index " << D->getIndex();
   if (D->isParameterPack())
     OS << " ...";
   NodeDumper.dumpName(D);
-  if (D->hasDefaultArgument())
-    dumpTemplateArgument(D->getDefaultArgument());
   if (auto *From = D->getDefaultArgStorage().getInheritedFrom())
     dumpDeclRef(From, D->defaultArgumentWasInherited() ? "inherited from"
                                                        : "previous");
+  if (D->hasDefaultArgument())
+    dumpTemplateArgument(D->getDefaultArgument());
 }
 
 void ASTDumper::VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
   NodeDumper.dumpType(D->getType());
   OS << " depth " << D->getDepth() << " index " << D->getIndex();
   if (D->isParameterPack())
     OS << " ...";
   NodeDumper.dumpName(D);
-  if (D->hasDefaultArgument())
-    dumpTemplateArgument(D->getDefaultArgument());
   if (auto *From = D->getDefaultArgStorage().getInheritedFrom())
     dumpDeclRef(From, D->defaultArgumentWasInherited() ? "inherited from"
                                                        : "previous");
+  if (D->hasDefaultArgument())
+    dumpTemplateArgument(D->getDefaultArgument());
 }
 
 void ASTDumper::VisitTemplateTemplateParmDecl(
     const TemplateTemplateParmDecl *D) {
   OS << " depth " << D->getDepth() << " index " << D->getIndex();
   if (D->isParameterPack())
     OS << " ...";
   NodeDumper.dumpName(D);
   dumpTemplateParameters(D->getTemplateParameters());
-  if (D->hasDefaultArgument())
-    dumpTemplateArgumentLoc(D->getDefaultArgument());
   if (auto *From = D->getDefaultArgStorage().getInheritedFrom())
     dumpDeclRef(From, D->defaultArgumentWasInherited() ? "inherited from"
                                                        : "previous");
+  if (D->hasDefaultArgument())
+    dumpTemplateArgumentLoc(D->getDefaultArgument());
 }
 
 void ASTDumper::VisitUsingDecl(const UsingDecl *D) {
   OS << ' ';
   if (D->getQualifier())
     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
   OS << D->getNameAsString();
 }

test/AST/ast-dump-decl.cpp

 // CHECK:        TemplateArgument
 // CHECK-NEXT:   TemplateArgument{{.*}}A
 // CHECK-NEXT:   TemplateTypeParmDecl
 // CHECK-NEXT:   CXXRecordDecl{{.*}} class TestClassTemplatePartial
 // CHECK-NEXT:   FieldDecl{{.*}} j
 
 // CHECK:      ClassTemplateDecl 0x{{[^ ]*}} prev 0x{{[^ ]*}} {{.*}} TestTemplateDefaultType
 // CHECK-NEXT:   TemplateTypeParmDecl
-// CHECK-NEXT:     TemplateArgument type 'int'
 // CHECK-NEXT:     inherited from TemplateTypeParm 0x{{[^ ]*}} 'T'
+// CHECK-NEXT:     TemplateArgument type 'int'
 
 // CHECK:      ClassTemplateDecl 0x{{[^ ]*}} prev 0x{{[^ ]*}} {{.*}} TestTemplateDefaultNonType
 // CHECK-NEXT:   NonTypeTemplateParmDecl
+// CHECK-NEXT:     inherited from NonTypeTemplateParm 0x{{[^ ]*}} 'I' 'int'
 // CHECK-NEXT:     TemplateArgument expr
 // CHECK-NEXT:       ConstantExpr
 // CHECK-NEXT:         IntegerLiteral
-// CHECK-NEXT:     inherited from NonTypeTemplateParm 0x{{[^ ]*}} 'I' 'int'
 
 // CHECK:      ClassTemplateDecl 0x{{[^ ]*}} prev 0x{{[^ ]*}} {{.*}} TestTemplateTemplateDefaultType
 // CHECK-NEXT:   TemplateTemplateParmDecl
 // CHECK-NEXT:     TemplateTypeParmDecl
-// CHECK-NEXT:     TemplateArgument
 // CHECK-NEXT:     inherited from TemplateTemplateParm 0x{{[^ ]*}} 'TT'
+// CHECK-NEXT:     TemplateArgument
 
 // PR15220 dump instantiation only once
 namespace testCanonicalTemplate {
   class A {};
 
   template<typename T> void TestFunctionTemplate(T);
   template<typename T> void TestFunctionTemplate(T);
   void bar(A a) { TestFunctionTemplate(a); }