Re-order content of template parameter dumps

[aaron.ballman]

test/AST/ast-dump-decl.cpp

331–332

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

331–332

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

331–332

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).

733

Elide braces.

lib/AST/ASTDumper.cpp

public:
     void dumpDeclContext(const DeclContext *DC);
     void dumpLookups(const DeclContext *DC, bool DumpDecls);
     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 dumpTemplateArgumentLoc(const TemplateArgumentLoc &A,
+                                 const Decl *From = nullptr,
+                                 const char *label = nullptr);
     void dumpTemplateArgumentList(const TemplateArgumentList &TAL);
     void dumpTemplateArgument(const TemplateArgument &A,
-                              SourceRange R = SourceRange());
+                              SourceRange R = SourceRange(),
+                              const Decl *From = nullptr,
+                              const char *label = nullptr);
 
     // Objective-C utilities.
     void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams);
 
     // Types
     void VisitComplexType(const ComplexType *T) {
       dumpTypeAsChild(T->getElementType());
     }

 }
 
 void ASTDumper::dumpTemplateArgumentListInfo(
     const TemplateArgumentListInfo &TALI) {
   for (unsigned i = 0, e = TALI.size(); i < e; ++i)
     dumpTemplateArgumentLoc(TALI[i]);
 }
 
-void ASTDumper::dumpTemplateArgumentLoc(const TemplateArgumentLoc &A) {
-  dumpTemplateArgument(A.getArgument(), A.getSourceRange());
+void ASTDumper::dumpTemplateArgumentLoc(const TemplateArgumentLoc &A,
+                                        const Decl *From, const char *label) {
+  dumpTemplateArgument(A.getArgument(), A.getSourceRange(), From, label);
 }
 
 void ASTDumper::dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
   for (unsigned i = 0, e = TAL.size(); i < e; ++i)
     dumpTemplateArgument(TAL[i]);
 }
 
-void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R) {
+void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R,
+                                     const Decl *From, const char *label) {
   dumpChild([=] {
     OS << "TemplateArgument";
     if (R.isValid())
       NodeDumper.dumpSourceRange(R);
 
+    if (From) {
+      dumpDeclRef(From, label);
+    }
+
     switch (A.getKind()) {
     case TemplateArgument::Null:
       OS << " null";
       break;
     case TemplateArgument::Type:
       OS << " type";
       NodeDumper.dumpType(A.getAsType());
       break;
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"
+    dumpTemplateArgument(D->getDefaultArgument(), SourceRange(),
+                         D->getDefaultArgStorage().getInheritedFrom(),
+                         D->defaultArgumentWasInherited() ? "inherited from"
                                                           : "previous");
 }
 
 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"
+    dumpTemplateArgument(D->getDefaultArgument(), SourceRange(),
+                         D->getDefaultArgStorage().getInheritedFrom(),
+                         D->defaultArgumentWasInherited() ? "inherited from"
                                                           : "previous");
 }
 
 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");
+    dumpTemplateArgumentLoc(
+        D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(),
+        D->defaultArgumentWasInherited() ? "inherited from" : "previous");
 }
 
 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-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:       inherited from TemplateTypeParm 0x{{[^ ]*}} 'T'
 
 // CHECK:      ClassTemplateDecl 0x{{[^ ]*}} prev 0x{{[^ ]*}} {{.*}} TestTemplateDefaultNonType
 // CHECK-NEXT:   NonTypeTemplateParmDecl
 // CHECK-NEXT:     TemplateArgument expr
+// CHECK-NEXT:       inherited from NonTypeTemplateParm 0x{{[^ ]*}} 'I' 'int'
 // 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:       inherited from TemplateTemplateParm 0x{{[^ ]*}} 'TT'
 
 // 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); }