[clang] AST/Print: honor AlwaysIncludeTypeForTemplateArgument policy

[mizvekov]

Summary

This redoes D103040 in a way that AlwaysIncludeTypeForTemplateArgument = false
policy is honored for printing template specialization types.
This can be seen for example when printing a canonicalized
dependent TemplateSpecializationType which has integral arguments.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

.

[v.g.vassilev]

This patch fixes our test case which we intended to fix with:

From 17e94a6a2adc3eb8d5fcc532eb1f3e57cc59b0fd Mon Sep 17 00:00:00 2001
From: Vassil Vassilev <[e-mail]>
Date: Mon, 23 May 2022 21:36:43 +0000
Subject: [PATCH] Fix type printing to not include the suffix when not needed.

before:
root.exe -l -b -q -e 'TClass::GetClass("std::array<int,3>")->Print()'
OBJ: TClassarray<int,3UL>

after: root.exe -l -b -q -e 'TClass::GetClass("std::array<int,3>")->Print()'
OBJ: TClassarray<int,3>

To be upstreamed.
---
 interpreter/llvm/src/tools/clang/lib/AST/TypePrinter.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/interpreter/llvm/src/tools/clang/lib/AST/TypePrinter.cpp b/interpreter/llvm/src/tools/clang/lib/AST/TypePrinter.cpp
index 5de22f76f458..844a5be12836 100644
--- a/interpreter/llvm/src/tools/clang/lib/AST/TypePrinter.cpp
+++ b/interpreter/llvm/src/tools/clang/lib/AST/TypePrinter.cpp
@@ -1452,7 +1452,8 @@ void TypePrinter::printTemplateId(const TemplateSpecializationType *T,
     T->getTemplateName().print(OS, Policy);
   }
 
-  printTemplateArgumentList(OS, T->template_arguments(), Policy);
+  printTemplateArgumentList(OS, T->template_arguments(), Policy,
+                            TD->getTemplateParameters());
   spaceBeforePlaceHolder(OS);
 }

The proposed patch is better because it is more precise whereas my approach above has multiple test failures and may be impossible to upstream.

This LGTM, but I'd like to see what @rsmith thinks.

[v.g.vassilev]

Let's move forward with this and rely on eventual post-commit review.

clang/lib/AST/TypePrinter.cpp

explicit ParamPolicyRAII(PrintingPolicy &Policy)
       Policy.SuppressSpecifiers = false;
     }
 
     ~ParamPolicyRAII() {
       Policy.SuppressSpecifiers = Old;
     }
   };
 
+  class DefaultTemplateArgsPolicyRAII {
+    PrintingPolicy &Policy;
+    bool Old;
+
+  public:
+    explicit DefaultTemplateArgsPolicyRAII(PrintingPolicy &Policy)
+        : Policy(Policy), Old(Policy.SuppressDefaultTemplateArgs) {
+      Policy.SuppressDefaultTemplateArgs = false;
+    }
+
+    ~DefaultTemplateArgsPolicyRAII() {
+      Policy.SuppressDefaultTemplateArgs = Old;
+    }
+  };
+
   class ElaboratedTypePolicyRAII {
     PrintingPolicy &Policy;
     bool SuppressTagKeyword;
     bool SuppressScope;
 
   public:
     explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) {
       SuppressTagKeyword = Policy.SuppressTagKeyword;
void TypePrinter::printSubstTemplateTypeParmPackAfter(
   printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
 }
 
 void TypePrinter::printTemplateId(const TemplateSpecializationType *T,
                                   raw_ostream &OS, bool FullyQualify) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl();
+  // FIXME: Null TD never excercised in test suite.
   if (FullyQualify && TD) {
     if (!Policy.SuppressScope)
       AppendScope(TD->getDeclContext(), OS, TD->getDeclName());
 
     OS << TD->getName();
   } else {
     T->getTemplateName().print(OS, Policy);
   }
 
-  printTemplateArgumentList(OS, T->template_arguments(), Policy);
+  DefaultTemplateArgsPolicyRAII TemplateArgs(Policy);
+  const TemplateParameterList *TPL = TD ? TD->getTemplateParameters() : nullptr;
+  printTemplateArgumentList(OS, T->template_arguments(), Policy, TPL);
   spaceBeforePlaceHolder(OS);
 }
 
 void TypePrinter::printTemplateSpecializationBefore(
                                             const TemplateSpecializationType *T,
                                             raw_ostream &OS) {
   printTemplateId(T, OS, Policy.FullyQualifiedName);
 }

clang/test/CXX/temp/temp.decls/temp.class.spec/p6.cpp

namespace rdar8651930 {
   int array1[Outer<int>::Inner<int, float>::value? -1 : 1];
 }
 
 namespace print_dependent_TemplateSpecializationType {
 
 template <class T, class U> struct Foo {
   template <unsigned long, class X, class Y> struct Bar;
   template <class Y> struct Bar<0, T, Y> {};
-  // expected-note-re@-1 {{previous declaration {{.*}} 'Bar<0UL, int, type-parameter-0-0>' is here}}
+  // expected-note-re@-1 {{previous declaration {{.*}} 'Bar<0, int, type-parameter-0-0>' is here}}
   template <class Y> struct Bar<0, U, Y> {};
   // expected-error@-1 {{partial specialization 'Bar<0, int, Y>' cannot be redeclared}}
 };
 template struct Foo<int, int>; // expected-note {{requested here}}
 
 } // namespace print_dependent_TemplateSpecializationType