Re-order content of template parameter dumps

[aaron.ballman]

test/AST/ast-dump-decl.cpp

330–331 ↗

(On Diff #177070)

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 ↗

(On Diff #177070)

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 ↗

(On Diff #177070)

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 ↗

(On Diff #177412)

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

733 ↗

(On Diff #177412)

Elide braces.

cfe/trunk/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);
     template <typename SpecializationDecl>
     void dumpTemplateDeclSpecialization(const SpecializationDecl *D,
                                         bool DumpExplicitInst,
                                         bool DumpRefOnly);
     template <typename TemplateDecl>
     void dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst);
 
     // Objective-C utilities.

 }
 
 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();
 }

cfe/trunk/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); }