[WIP][clang] Add PrintingPolicy callback for identifying default template arguments

[Michael137]

Summary

This patch adds a hook into the TypePrinter to allow clients
decide whether a template argument corresponds to the default
parameter.

Motivation

DWARF encodes information about template instantiations, but
not about the generic definition of a template. If an argument
in a template instantiation corresponds to the default parameter
of the generic template then DWARF will attach a DW_AT_default_value
to that argument. LLDB uses the Clang TypePrinter for
displaying/formatting C++ types but currently can't give Clang the ClassTemplateDecl
that it expects. Since LLDB does know whether a particular instantiation has
default arguments, this patch allows LLDB (and other clients with external AST sources)
to help Clang in identifying those default arguments.

Alternatives

1. Encode information about generic template definitions in DWARF. It's unclear how long it would take to get this proposed and implemented and whether something like this would work in the first place. If we could construct ClassTemplateDecls with the correct generic parameters this patch wouldn't be required.

2. Add something like a bool IsDefaulted somewhere in Clang, e.g., in TemplateArgument and consult it from the TypePrinter. This would be much simpler but requires adding a field on one of the Clang types

[Michael137]

An example of how this would be used from LLDB is: https://reviews.llvm.org/D140145

[Michael137]

• Remove debug print in test

[aprantl]

Overall this seems to have a pretty small surface area, so I'd be fine with including this.

clang/lib/AST/TypePrinter.cpp

2095

maybe this body becomes slightly less oddly indented when converting it to a range-based for with a counter?

[Michael137]

@aaron.ballman we're trying to fix printing of C++ types with default template arguments in LLDB. Currently DWARF doesn't have the necessary info to construct a ClassTemplateDecl with generic parameters, which means the logic for suppressing them in the TypePrinter doesn't quite work.

This patch outlines of one approach we considered. We add a hook into the TypePrinter to allow external AST sources to answer the question "is template argument X defaulted?".

Another alternative would be to have a TemplateArgument::IsDefaulted which gets set in LLDB and read from the TypePrinter.

Do you think either of these approaches would be fine for inclusion?

clang/include/clang/AST/PrettyPrinter.h

52

The TrisState is needed because LLDB has two AST sources:

1. DWARF
2. clang modules

When we import a type from a clang module we would never have consulted DWARF about whether a parameter was defaulted. So instead of more complex bookkeeping it seemed simpler to say "if we've never seen this decl when parsing DWARF, I can't say anything about the default-ness of the arguments"

[Michael137]

• Fix test. Move variable into loop

[Michael137]

• Rebase

[Michael137]

putting into review queue to hear people's opinion on something along these lines

[dblaikie]

clang/include/clang/AST/PrettyPrinter.h

52

We don't usually use the k prefix for enums (the style guide mentions using an acronym like TS_ - though even that's unnecessary with an enum class, where you have to use EnumClassName prefix anyway, so there's no issue with ambiguity/name collisions of the enumerators)

But also, I'm guessing we probably use std::optional<bool> for this sort of thing more frequently than defining a three-state enum (even though std::optional<bool> can be a bit awkward to use/error prone, it's not too bad for limited uses like this).

[aaron.ballman]

Add something like a bool IsDefaulted somewhere in Clang, e.g., in TemplateArgument and consult it from the TypePrinter. This would be much simpler but requires adding a field on one of the Clang types

I think this might be worth exploring as a cleaner solution to the problem. TemplateArgument has a union of structures for the various kinds of template arguments it represents (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/TemplateBase.h#L140). All of the structures in that union start with an unsigned Kind field to discriminate between the members. There are only 8 kinds currently (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/TemplateBase.h#L63), so we could turn Kind into a bit-field and then steal a bit for IsDefaulted without increasing memory overhead. Do you think that's a reasonable approach to try instead?

[dblaikie]

In D140423#4051262, @aaron.ballman wrote:

Add something like a bool IsDefaulted somewhere in Clang, e.g., in TemplateArgument and consult it from the TypePrinter. This would be much simpler but requires adding a field on one of the Clang types

I think this might be worth exploring as a cleaner solution to the problem. TemplateArgument has a union of structures for the various kinds of template arguments it represents (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/TemplateBase.h#L140). All of the structures in that union start with an unsigned Kind field to discriminate between the members. There are only 8 kinds currently (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/TemplateBase.h#L63), so we could turn Kind into a bit-field and then steal a bit for IsDefaulted without increasing memory overhead. Do you think that's a reasonable approach to try instead?

FWIW, I Think I discouraged @Michael137 from going down that direction since it felt weird to me to add that sort of thing to the Clang ASTs for an lldb-only use case, and a callback seemed more suitable. But this is hardly my wheelhouse - if you reckon that's the better direction, carry on, I expect @Michael137 will be on board with that.

[aaron.ballman]

In D140423#4052271, @dblaikie wrote:

In D140423#4051262, @aaron.ballman wrote:

Add something like a bool IsDefaulted somewhere in Clang, e.g., in TemplateArgument and consult it from the TypePrinter. This would be much simpler but requires adding a field on one of the Clang types

I think this might be worth exploring as a cleaner solution to the problem. TemplateArgument has a union of structures for the various kinds of template arguments it represents (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/TemplateBase.h#L140). All of the structures in that union start with an unsigned Kind field to discriminate between the members. There are only 8 kinds currently (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/TemplateBase.h#L63), so we could turn Kind into a bit-field and then steal a bit for IsDefaulted without increasing memory overhead. Do you think that's a reasonable approach to try instead?

FWIW, I Think I discouraged @Michael137 from going down that direction since it felt weird to me to add that sort of thing to the Clang ASTs for an lldb-only use case, and a callback seemed more suitable. But this is hardly my wheelhouse - if you reckon that's the better direction, carry on, I expect @Michael137 will be on board with that.

Adding in @erichkeane as templates code owner in case he has opinions.

I agree it's a bit weird to modify the AST only for lldb only, but adding a callback to the printing policy is basically an lldb-only change as well (I don't imagine folks would use that callback all that often). So my thinking is that if we can encode the information in the AST for effectively zero cost, that helps every consumer of the AST (thinking about things like clang-tidy) and not just people printing. However, this is not a strongly held position, so if there's a preference for the current approach, it seems workable to me.

[erichkeane]

A Class template instantiation SHOULD have its link back to the class template, and should be able to calculate whether the template argument is defaulted, right? At least if it is the SAME as the default (that is, I'm not sure how well we can tell the difference between a defaulted arg, and a arg set to the default value).

I wouldn't expect a bool to be necessary, and I see isSubstitutedDefaultArgument seems to do that work, right?

So I guess I wonder why 'print the defaulted template args' isn't just a printing-policy?

[dblaikie]

In D140423#4052540, @erichkeane wrote:

A Class template instantiation SHOULD have its link back to the class template, and should be able to calculate whether the template argument is defaulted, right?

For a normal/clang-built AST, yes. But as mentioned in this review description, for LLDB, DWARF doesn't encode enough information to make the class template properly. So it only knows if a given class template specialization's argument is defaulted.

[Michael137]

In D140423#4052442, @aaron.ballman wrote:

In D140423#4052271, @dblaikie wrote:

In D140423#4051262, @aaron.ballman wrote:

Add something like a bool IsDefaulted somewhere in Clang, e.g., in TemplateArgument and consult it from the TypePrinter. This would be much simpler but requires adding a field on one of the Clang types

I think this might be worth exploring as a cleaner solution to the problem. TemplateArgument has a union of structures for the various kinds of template arguments it represents (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/TemplateBase.h#L140). All of the structures in that union start with an unsigned Kind field to discriminate between the members. There are only 8 kinds currently (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/TemplateBase.h#L63), so we could turn Kind into a bit-field and then steal a bit for IsDefaulted without increasing memory overhead. Do you think that's a reasonable approach to try instead?

FWIW, I Think I discouraged @Michael137 from going down that direction since it felt weird to me to add that sort of thing to the Clang ASTs for an lldb-only use case, and a callback seemed more suitable. But this is hardly my wheelhouse - if you reckon that's the better direction, carry on, I expect @Michael137 will be on board with that.

Adding in @erichkeane as templates code owner in case he has opinions.

I agree it's a bit weird to modify the AST only for lldb only, but adding a callback to the printing policy is basically an lldb-only change as well (I don't imagine folks would use that callback all that often). So my thinking is that if we can encode the information in the AST for effectively zero cost, that helps every consumer of the AST (thinking about things like clang-tidy) and not just people printing. However, this is not a strongly held position, so if there's a preference for the current approach, it seems workable to me.

Thanks for taking a look @aaron.ballman @erichkeane

I prepared an alternative draft patch series with your suggestion of adding an IsDefaulted bit to TemplateArgument:

• https://reviews.llvm.org/D141826
• https://reviews.llvm.org/D141827

Is this what you had in mind?

This *significantly* simplifies the LLDB support: https://reviews.llvm.org/D141828

So I'd prefer this over the callback approach TBH.

A Class template instantiation SHOULD have its link back to the class template, and should be able to calculate whether the template argument is defaulted, right? At least if it is the SAME as the default (that is, I'm not sure how well we can tell the difference between a defaulted arg, and a arg set to the default value).

I wouldn't expect a bool to be necessary, and I see isSubstitutedDefaultArgument seems to do that work, right?

As @dblaikie mentioned, unfortunately LLDB currently isn't able to construct the ClassTemplateDecl in a way where isSubstitutedDefaultArgument would correctly deduce whether a template instantiation has defaulted arguments. In DWARF we only have info about a template instantiation (i.e., the structure of the generic template parameters is not encoded). So we can't supply (Non)TypeTemplateParamDecl::setDefaultArgument with the generic arguments Clang expects. The ClassTemplateDecl parameters are set up here: https://github.com/llvm/llvm-project/blob/main/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp#L1391-L1402

Regardless of how complex the template parameters get, LLDB just turns each into a plain (Non)TypeTemplateParamDecl

[erichkeane]

In D140423#4055722, @Michael137 wrote:

In D140423#4052442, @aaron.ballman wrote:

In D140423#4052271, @dblaikie wrote:

In D140423#4051262, @aaron.ballman wrote:

Add something like a bool IsDefaulted somewhere in Clang, e.g., in TemplateArgument and consult it from the TypePrinter. This would be much simpler but requires adding a field on one of the Clang types

I think this might be worth exploring as a cleaner solution to the problem. TemplateArgument has a union of structures for the various kinds of template arguments it represents (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/TemplateBase.h#L140). All of the structures in that union start with an unsigned Kind field to discriminate between the members. There are only 8 kinds currently (https://github.com/llvm/llvm-project/blob/main/clang/include/clang/AST/TemplateBase.h#L63), so we could turn Kind into a bit-field and then steal a bit for IsDefaulted without increasing memory overhead. Do you think that's a reasonable approach to try instead?

FWIW, I Think I discouraged @Michael137 from going down that direction since it felt weird to me to add that sort of thing to the Clang ASTs for an lldb-only use case, and a callback seemed more suitable. But this is hardly my wheelhouse - if you reckon that's the better direction, carry on, I expect @Michael137 will be on board with that.

Adding in @erichkeane as templates code owner in case he has opinions.

I agree it's a bit weird to modify the AST only for lldb only, but adding a callback to the printing policy is basically an lldb-only change as well (I don't imagine folks would use that callback all that often). So my thinking is that if we can encode the information in the AST for effectively zero cost, that helps every consumer of the AST (thinking about things like clang-tidy) and not just people printing. However, this is not a strongly held position, so if there's a preference for the current approach, it seems workable to me.

Thanks for taking a look @aaron.ballman @erichkeane

I prepared an alternative draft patch series with your suggestion of adding an IsDefaulted bit to TemplateArgument:

• https://reviews.llvm.org/D141826
• https://reviews.llvm.org/D141827

Is this what you had in mind?

This *significantly* simplifies the LLDB support: https://reviews.llvm.org/D141828

So I'd prefer this over the callback approach TBH.

A Class template instantiation SHOULD have its link back to the class template, and should be able to calculate whether the template argument is defaulted, right? At least if it is the SAME as the default (that is, I'm not sure how well we can tell the difference between a defaulted arg, and a arg set to the default value).

I wouldn't expect a bool to be necessary, and I see isSubstitutedDefaultArgument seems to do that work, right?

As @dblaikie mentioned, unfortunately LLDB currently isn't able to construct the ClassTemplateDecl in a way where isSubstitutedDefaultArgument would correctly deduce whether a template instantiation has defaulted arguments. In DWARF we only have info about a template instantiation (i.e., the structure of the generic template parameters is not encoded). So we can't supply (Non)TypeTemplateParamDecl::setDefaultArgument with the generic arguments Clang expects. The ClassTemplateDecl parameters are set up here: https://github.com/llvm/llvm-project/blob/main/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp#L1391-L1402

Regardless of how complex the template parameters get, LLDB just turns each into a plain (Non)TypeTemplateParamDecl

Got it, I missed that part, I'm not too familiar with how LLDB works in this case. I'll take a look at those other patches.

[Michael137]

Abandoning in favour of https://reviews.llvm.org/D141826

clang/include/clang/AST/PrettyPrinter.h

 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 
 namespace clang {
 
 class DeclContext;
 class LangOptions;
 class Stmt;
+class ClassTemplateSpecializationDecl;
 
 class PrinterHelper {
 public:
   virtual ~PrinterHelper();
   virtual bool handledStmt(Stmt* E, raw_ostream& OS) = 0;
 };
 
 /// Callbacks to use to customize the behavior of the pretty-printer.
public:
   /// When printing type to be inserted into code in specific context, this
   /// callback can be used to avoid printing the redundant part of the
   /// qualifier. For example, when inserting code inside namespace foo, we
   /// should print bar::SomeType instead of foo::bar::SomeType.
   /// To do this, shouldPrintScope should return true on "foo" NamespaceDecl.
   /// The printing stops at the first isScopeVisible() == true, so there will
   /// be no calls with outer scopes.
   virtual bool isScopeVisible(const DeclContext *DC) const { return false; }
+
+  enum class TriState : int { kYes, kNo, kUnknown };
+
+  virtual TriState
+  IsTemplateArgumentDefaulted(clang::ClassTemplateSpecializationDecl const *D,
+                              size_t ArgIndex) const {
+    return TriState::kNo;
+  }
 };
 
 /// Describes how types, statements, expressions, and declarations should be
 /// printed.
 ///
 /// This type is intended to be small and suitable for passing by value.
 /// It is very frequently copied.
 struct PrintingPolicy {

clang/include/clang/AST/Type.h

 
 class BTFTypeTagAttr;
 class ExtQuals;
 class QualType;
 class ConceptDecl;
 class TagDecl;
 class TemplateParameterList;
 class Type;
+class ClassTemplateSpecializationDecl;
 
 enum {
   TypeAlignmentInBits = 4,
   TypeAlignment = 1 << TypeAlignmentInBits
 };
 
 namespace serialization {
   template <class T> class AbstractTypeReader;
void printTemplateArgumentList(raw_ostream &OS,
                                const PrintingPolicy &Policy,
                                const TemplateParameterList *TPL = nullptr);
 
 void printTemplateArgumentList(raw_ostream &OS,
                                const TemplateArgumentListInfo &Args,
                                const PrintingPolicy &Policy,
                                const TemplateParameterList *TPL = nullptr);
 
+void printTemplateArgumentList(
+    raw_ostream &OS, ArrayRef<TemplateArgument> Args,
+    const PrintingPolicy &Policy, const TemplateParameterList *TPL,
+    const clang::ClassTemplateSpecializationDecl *CTSD);
+
 /// Make a best-effort determination of whether the type T can be produced by
 /// substituting Args into the default argument of Param.
 bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
                                   const NamedDecl *Param,
                                   ArrayRef<TemplateArgument> Args,
                                   unsigned Depth);
 
 /// The injected class name of a C++ class template or class

clang/lib/AST/TypePrinter.cpp

else
       OS << "(anonymous namespace)::";
   } else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
     AppendScope(DC->getParent(), OS, Spec->getDeclName());
     IncludeStrongLifetimeRAII Strong(Policy);
     OS << Spec->getIdentifier()->getName();
     const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
     printTemplateArgumentList(
         OS, TemplateArgs.asArray(), Policy,
-        Spec->getSpecializedTemplate()->getTemplateParameters());
+        Spec->getSpecializedTemplate()->getTemplateParameters(), Spec);
     OS << "::";
   } else if (const auto *Tag = dyn_cast<TagDecl>(DC)) {
     AppendScope(DC->getParent(), OS, Tag->getDeclName());
     if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
       OS << Typedef->getIdentifier()->getName() << "::";
     else if (Tag->getIdentifier())
       OS << Tag->getIdentifier()->getName() << "::";
     else
if (!Policy.PrintCanonicalTypes && TAW) {
       Args = TST->template_arguments();
     } else {
       const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
       Args = TemplateArgs.asArray();
     }
     IncludeStrongLifetimeRAII Strong(Policy);
     printTemplateArgumentList(
         OS, Args, Policy,
-        Spec->getSpecializedTemplate()->getTemplateParameters());
+        Spec->getSpecializedTemplate()->getTemplateParameters(), Spec);
   }
 
   spaceBeforePlaceHolder(OS);
 }
 
 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
   // Print the preferred name if we have one for this type.
   if (Policy.UsePreferredNames) {
if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Param)) {
     return NTTPD->hasDefaultArgument() &&
            isSubstitutedTemplateArgument(Ctx, Arg, NTTPD->getDefaultArgument(),
                                          Args, Depth);
   }
   return false;
 }
 
 template <typename TA>
-static ArrayRef<TA> dropDefaultedArguments(ArrayRef<TA> Args,
-                                           const PrintingPolicy &Policy,
-                                           const TemplateParameterList *TPL) {
+static ArrayRef<TA>
+dropDefaultedArguments(ArrayRef<TA> Args, const PrintingPolicy &Policy,
+                       const TemplateParameterList *TPL,
+                       const ClassTemplateSpecializationDecl *CTSD) {
+  using TriState = PrintingCallbacks::TriState;
+
   ASTContext &Ctx = TPL->getParam(0)->getASTContext();
   llvm::SmallVector<TemplateArgument, 8> OrigArgs;
   for (const TA &A : Args)
     OrigArgs.push_back(getArgument(A));
-  while (!Args.empty() &&
-         isSubstitutedDefaultArgument(Ctx, getArgument(Args.back()),
-                                      TPL->getParam(Args.size() - 1), OrigArgs,
-                                      TPL->getDepth()))
+
+  auto const *Callbacks = Policy.Callbacks;
+
+  while (!Args.empty()) {
+    auto IsDefaulted = PrintingCallbacks::TriState::kUnknown;
+    if (Callbacks != nullptr)
+      IsDefaulted =
+          Callbacks->IsTemplateArgumentDefaulted(CTSD, Args.size() - 1);
+
+    if (IsDefaulted == TriState::kUnknown)
+      IsDefaulted = isSubstitutedDefaultArgument(Ctx, getArgument(Args.back()),
+                                                 TPL->getParam(Args.size() - 1),
+                                                 OrigArgs, TPL->getDepth())
+                        ? TriState::kYes
+                        : TriState::kNo;
+
+    if (IsDefaulted != TriState::kYes)
+      break;
+
     Args = Args.drop_back();
+  }
 
   return Args;
 }
 
 template <typename TA>
 static void
 printTo(raw_ostream &OS, ArrayRef<TA> Args, const PrintingPolicy &Policy,
-        const TemplateParameterList *TPL, bool IsPack, unsigned ParmIndex) {
+        const TemplateParameterList *TPL, bool IsPack, unsigned ParmIndex,
+        const ClassTemplateSpecializationDecl *CTSD) {
   // Drop trailing template arguments that match default arguments.
   if (TPL && Policy.SuppressDefaultTemplateArgs &&
       !Policy.PrintCanonicalTypes && !Args.empty() && !IsPack &&
       Args.size() <= TPL->size()) {
-    Args = dropDefaultedArguments(Args, Policy, TPL);
+    Args = dropDefaultedArguments(Args, Policy, TPL, CTSD);
   }
 
   const char *Comma = Policy.MSVCFormatting ? "," : ", ";
   if (!IsPack)
     OS << '<';
 
   bool NeedSpace = false;
   bool FirstArg = true;
   for (const auto &Arg : Args) {
     // Print the argument into a string.
     SmallString<128> Buf;
     llvm::raw_svector_ostream ArgOS(Buf);
     const TemplateArgument &Argument = getArgument(Arg);
     if (Argument.getKind() == TemplateArgument::Pack) {
       if (Argument.pack_size() && !FirstArg)
         OS << Comma;
       printTo(ArgOS, Argument.getPackAsArray(), Policy, TPL,
-              /*IsPack*/ true, ParmIndex);
+              /*IsPack*/ true, ParmIndex, CTSD);
     } else {
       if (!FirstArg)
         OS << Comma;
       // Tries to print the argument with location info if exists.
       printArgument(Arg, Policy, ArgOS,
                     TemplateParameterList::shouldIncludeTypeForArgument(
                         Policy, TPL, ParmIndex));
     }
void clang::printTemplateArgumentList(raw_ostream &OS,
                                       const TemplateParameterList *TPL) {
   printTemplateArgumentList(OS, Args.arguments(), Policy, TPL);
 }
 
 void clang::printTemplateArgumentList(raw_ostream &OS,
                                       ArrayRef<TemplateArgument> Args,
                                       const PrintingPolicy &Policy,
                                       const TemplateParameterList *TPL) {
-  printTo(OS, Args, Policy, TPL, /*isPack*/ false, /*parmIndex*/ 0);
+  printTo(OS, Args, Policy, TPL, /*isPack*/ false, /*parmIndex*/ 0, nullptr);
 }
 
 void clang::printTemplateArgumentList(raw_ostream &OS,
                                       ArrayRef<TemplateArgumentLoc> Args,
                                       const PrintingPolicy &Policy,
                                       const TemplateParameterList *TPL) {
-  printTo(OS, Args, Policy, TPL, /*isPack*/ false, /*parmIndex*/ 0);
+  printTo(OS, Args, Policy, TPL, /*isPack*/ false, /*parmIndex*/ 0, nullptr);
+}
+
+void clang::printTemplateArgumentList(
+    raw_ostream &OS, ArrayRef<TemplateArgument> Args,
+    const PrintingPolicy &Policy, const TemplateParameterList *TPL,
+    const clang::ClassTemplateSpecializationDecl *CTSD) {
+  printTo(OS, Args, Policy, TPL, /*isPack*/ false, /*parmIndex*/ 0, CTSD);
 }
 
 std::string Qualifiers::getAsString() const {
   LangOptions LO;
   return getAsString(PrintingPolicy(LO));
 }
 
 // Appends qualifiers to the given string, separated by spaces.  Will

clang/unittests/AST/TypePrinterTest.cpp

TEST(TypePrinter, TemplateIdWithNTTP) {
 
   ASSERT_TRUE(PrintedTypeMatches(
       Code, {"-std=c++20"}, Matcher,
       R"(ASCII<Str<52>{"this nontype template argument is too long to print"}> &&)",
       [](PrintingPolicy &Policy) {
         Policy.EntireContentsOfLargeArray = true;
       }));
 }
+
+TEST(TypePrinter, TemplateParameterListWithCallback) {
+  constexpr char Code[] = R"cpp(
+    template <typename T1,         
+              typename T2 = double,
+              typename T3 = int,   
+              int      T4 = 42>    
+    struct Foo {                   
+    };                             
+                                   
+    Foo<char> X;                   
+  )cpp";
+  auto Matcher = classTemplateSpecializationDecl(
+      hasName("Foo"), has(cxxConstructorDecl(
+                          has(parmVarDecl(hasType(qualType().bind("id")))))));
+
+  struct DefaulterCallback final : public PrintingCallbacks {
+    virtual TriState
+    IsTemplateArgumentDefaulted(clang::ClassTemplateSpecializationDecl const *,
+                                size_t ArgIndex) const {
+      if (ArgIndex > 1)
+        return TriState::kYes;
+
+      return TriState::kNo;
+    }
+  };
+
+  DefaulterCallback Callback;
+
+  ASSERT_TRUE(PrintedTypeMatches(Code, {""}, Matcher,
+                                 R"(const Foo<char, double> &)",
+                                 [&Callback](PrintingPolicy &Policy) {
+                                   Policy.SuppressDefaultTemplateArgs = true;
+                                   Policy.Callbacks = &Callback;
+                                 }));
+}