[clang][TemplateBase] Add IsDefaulted bit to TemplateArgument

[Michael137]

Summary

Summary

This patch adds a IsDefaulted field to clang::TemplateArgument.

To prevent memory footprint increase we steal 1 bit from ArgKind.

Background

In LLDB we construct ASTs from debug-info and hand it to clang
to perform actions such as printing/formatting typenames.
Some debug formats, specifically DWARF, may only encode information
about class template instantiations, losing the structure of the generic
class definition. However, the clang::TypePrinter needs a properly
constructed ClassTemplateDecl with generic default argument decls
to be able to deduce whether a ClassTemplateSpecializationDecl was
instantiatiated with TemplateArguments that correspond to the
defaults. LLDB does know whether a particular template argument was
defaulted, but can't currently tell clang about it.

This patch allows LLDB to set the defaulted-ness of a TemplateArgument
and thus benefit more from clang::TypePrinter.

See discussion in https://reviews.llvm.org/D140423

Testing

• TODO

[erichkeane]

This seems innocuous enough/easy enough to use. I'd like a comment on the functions at least and types in TemplateBase.h to specify that this is for printing-policy only? Alternatively (and perhaps MUCH more appreciated) would be to make sure we mark the defaulted during AST generation as well.

[Michael137]

In D141826#4058866, @erichkeane wrote:

This seems innocuous enough/easy enough to use. I'd like a comment on the functions at least and types in TemplateBase.h to specify that this is for printing-policy only? Alternatively (and perhaps MUCH more appreciated) would be to make sure we mark the defaulted during AST generation as well.

I'll have a look at doing that

Are you suggesting we move the substitution check that the TypePrinter currently does to the point where we construct the specialisation decls? So the TypePrinter only needs to call TemplateArgument::getIsDefaulted? I like the sound of that.

Unfortunately we'd still need the setIsDefaulted because of the DWARF limitation in LLDB

[erichkeane]

In D141826#4059073, @Michael137 wrote:

In D141826#4058866, @erichkeane wrote:

This seems innocuous enough/easy enough to use. I'd like a comment on the functions at least and types in TemplateBase.h to specify that this is for printing-policy only? Alternatively (and perhaps MUCH more appreciated) would be to make sure we mark the defaulted during AST generation as well.

I'll have a look at doing that

Are you suggesting we do the substitution check that the TypePrinter currently does when constructing the specialisation decls? So the TypePrinter simply needs to check the TemplateArgument::getIsDefaulted? I like the sound of that.

Unfortunately we'd still need the setIsDefaulted because of the DWARF limitation in LLDB

Yes, thats my thought. Of course we'd still need the 'setIsDefaulted', but at least it would be something that coudl be generally useful.

[dblaikie]

In D141826#4059088, @erichkeane wrote:

In D141826#4059073, @Michael137 wrote:

In D141826#4058866, @erichkeane wrote:

This seems innocuous enough/easy enough to use. I'd like a comment on the functions at least and types in TemplateBase.h to specify that this is for printing-policy only? Alternatively (and perhaps MUCH more appreciated) would be to make sure we mark the defaulted during AST generation as well.

I'll have a look at doing that

Are you suggesting we do the substitution check that the TypePrinter currently does when constructing the specialisation decls? So the TypePrinter simply needs to check the TemplateArgument::getIsDefaulted? I like the sound of that.

Unfortunately we'd still need the setIsDefaulted because of the DWARF limitation in LLDB

Yes, thats my thought. Of course we'd still need the 'setIsDefaulted', but at least it would be something that coudl be generally useful.

Yeah, +1 for ensuring everything goes through the one solution (the IsDefaulted flag, in this case) - it'll make sure the flag support is well tested & is less likely to bitrot/break lldb's use case due to unrelated clang changes.

[Michael137]

• setIsDefaulted when constructing ClassTemplateSpecializationDecls
• Propagate IsDefaulted on serialization

[Michael137]

In D141826#4059088, @erichkeane wrote:

In D141826#4059073, @Michael137 wrote:

In D141826#4058866, @erichkeane wrote:

This seems innocuous enough/easy enough to use. I'd like a comment on the functions at least and types in TemplateBase.h to specify that this is for printing-policy only? Alternatively (and perhaps MUCH more appreciated) would be to make sure we mark the defaulted during AST generation as well.

I'll have a look at doing that

Are you suggesting we do the substitution check that the TypePrinter currently does when constructing the specialisation decls? So the TypePrinter simply needs to check the TemplateArgument::getIsDefaulted? I like the sound of that.

Unfortunately we'd still need the setIsDefaulted because of the DWARF limitation in LLDB

Yes, thats my thought. Of course we'd still need the 'setIsDefaulted', but at least it would be something that coudl be generally useful.

So I've been having a go at this. The latest diff sets the bit when creating ClassTemplateSpecializationDecls. However, we end up having to copy the ArrayRef<TemplateArgument> twice (because of the current assumptions that a TemplateArgumentList is immutable, which seems like a nice property to maintain). That seems iffy.

I also had to add the flag to the TemplateArgument tablegen description to support deserialized ClassTemplateSpecializationDecl.

I've been playing around with setting the flag at construction of TemplateArguments instead. Not sure how much cleaner that's going to be because so far I've not found a good single point of entry (been looking at CheckTemplateArgumentList in SemaTemplate)

[Michael137]

• Rename test

[dblaikie]

In D141826#4072609, @Michael137 wrote:

In D141826#4059088, @erichkeane wrote:

In D141826#4059073, @Michael137 wrote:

In D141826#4058866, @erichkeane wrote:

This seems innocuous enough/easy enough to use. I'd like a comment on the functions at least and types in TemplateBase.h to specify that this is for printing-policy only? Alternatively (and perhaps MUCH more appreciated) would be to make sure we mark the defaulted during AST generation as well.

I'll have a look at doing that

Are you suggesting we do the substitution check that the TypePrinter currently does when constructing the specialisation decls? So the TypePrinter simply needs to check the TemplateArgument::getIsDefaulted? I like the sound of that.

Unfortunately we'd still need the setIsDefaulted because of the DWARF limitation in LLDB

Yes, thats my thought. Of course we'd still need the 'setIsDefaulted', but at least it would be something that coudl be generally useful.

So I've been having a go at this. The latest diff sets the bit when creating ClassTemplateSpecializationDecls. However, we end up having to copy the ArrayRef<TemplateArgument> twice (because of the current assumptions that a TemplateArgumentList is immutable, which seems like a nice property to maintain). That seems iffy.

I also had to add the flag to the TemplateArgument tablegen description to support deserialized ClassTemplateSpecializationDecl.

I've been playing around with setting the flag at construction of TemplateArguments instead. Not sure how much cleaner that's going to be because so far I've not found a good single point of entry (been looking at CheckTemplateArgumentList in SemaTemplate)

Yep, I think that'd be the idea, if there's somewhere to do it - rather than updating/copying it on every specialization.

[Michael137]

• Set IsDefaulted when checking template arguments in clang::Sema

[Michael137]

• Fix formatting

[Michael137]

• Don't need to pass flag to NewArgs

[Michael137]

Latest diff now sets the IsDefaulted flag from Sema::CheckTemplateArgumentList, which is the best point I could find for creation of TemplateArgument which are fed into the various specialization decls (and later on the TypePrinter).

The review description has some additional info about the changes.

As a result of moving the isSubstitutedDefaultArgument higher up into Sema, we can simplify the other remaining callers:

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

Still unsure if changing the TemplateArgument constructors is cleaner than simply calling setIsDefaulted from the tablegen creators but I'm open to suggestions.

[Michael137]

• Remove redundant constructor call change

[bolshakov-a]

clang/lib/AST/ASTContext.cpp

6842

@Michael137, hasn't IsDefaulted parameter forgotten here?

clang/include/clang/AST/PropertiesBase.td

let Class = PropertyTypeCase<TemplateArgument, "Null"> in {
   def : Creator<[{
     return TemplateArgument();
   }]>;
 }
 let Class = PropertyTypeCase<TemplateArgument, "Type"> in {
   def : Property<"type", QualType> {
     let Read = [{ node.getAsType() }];
   }
+  def : Property<"isDefaulted", Bool> {
+    let Read = [{ node.getIsDefaulted() }];
+  }
   def : Creator<[{
-    return TemplateArgument(type);
+    return TemplateArgument(type, /* isNullPtr */ false, isDefaulted);
   }]>;
 }
 let Class = PropertyTypeCase<TemplateArgument, "Declaration"> in {
   def : Property<"declaration", ValueDeclRef> {
     let Read = [{ node.getAsDecl() }];
   }
   def : Property<"parameterType", QualType> {
     let Read = [{ node.getParamTypeForDecl() }];
   }
+  def : Property<"isDefaulted", Bool> {
+    let Read = [{ node.getIsDefaulted() }];
+  }
   def : Creator<[{
-    return TemplateArgument(declaration, parameterType);
+    return TemplateArgument(declaration, parameterType, isDefaulted);
   }]>;
 }
 let Class = PropertyTypeCase<TemplateArgument, "NullPtr"> in {
   def : Property<"type", QualType> {
     let Read = [{ node.getNullPtrType() }];
   }
+  def : Property<"isDefaulted", Bool> {
+    let Read = [{ node.getIsDefaulted() }];
+  }
   def : Creator<[{
-    return TemplateArgument(type, /*nullptr*/ true);
+    return TemplateArgument(type, /*nullptr*/ true, isDefaulted);
   }]>;
 }
 let Class = PropertyTypeCase<TemplateArgument, "Integral"> in {
   def : Property<"value", APSInt> {
     let Read = [{ node.getAsIntegral() }];
   }
   def : Property<"type", QualType> {
     let Read = [{ node.getIntegralType() }];
   }
+  def : Property<"isDefaulted", Bool> {
+    let Read = [{ node.getIsDefaulted() }];
+  }
   def : Creator<[{
-    return TemplateArgument(ctx, value, type);
+    return TemplateArgument(ctx, value, type, isDefaulted);
   }]>;
 }
 let Class = PropertyTypeCase<TemplateArgument, "Template"> in {
   def : Property<"name", TemplateName> {
     let Read = [{ node.getAsTemplateOrTemplatePattern() }];
   }
+  def : Property<"isDefaulted", Bool> {
+    let Read = [{ node.getIsDefaulted() }];
+  }
   def : Creator<[{
-    return TemplateArgument(name);
+    return TemplateArgument(name, isDefaulted);
   }]>;
 }
 let Class = PropertyTypeCase<TemplateArgument, "TemplateExpansion"> in {
   def : Property<"name", TemplateName> {
     let Read = [{ node.getAsTemplateOrTemplatePattern() }];
   }
   def : Property<"numExpansions", Optional<UInt32>> {
     let Read = [{
       // Translate unsigned -> uint32_t just in case.
       llvm::transformOptional(node.getNumTemplateExpansions(),
                               [](unsigned i) { return uint32_t(i); })
     }];
   }
+  def : Property<"isDefaulted", Bool> {
+    let Read = [{ node.getIsDefaulted() }];
+  }
   def : Creator<[{
     auto numExpansionsUnsigned = llvm::transformOptional(
         numExpansions, [](uint32_t i) { return unsigned(i); });
 
-    return TemplateArgument(name, numExpansionsUnsigned);
+    return TemplateArgument(name, numExpansionsUnsigned, isDefaulted);
   }]>;
 }
 let Class = PropertyTypeCase<TemplateArgument, "Expression"> in {
   def : Property<"expression", ExprRef> {
     let Read = [{ node.getAsExpr() }];
   }
+  def : Property<"isDefaulted", Bool> {
+    let Read = [{ node.getIsDefaulted() }];
+  }
   def : Creator<[{
-    return TemplateArgument(expression);
+    return TemplateArgument(expression, isDefaulted);
   }]>;
 }
 let Class = PropertyTypeCase<TemplateArgument, "Pack"> in {
   def : Property<"elements", Array<TemplateArgument>> {
     let Read = [{ node.pack_elements() }];
   }
   def : Creator<[{
     // Copy the pack into the ASTContext.
     TemplateArgument *ctxElements = new (ctx) TemplateArgument[elements.size()];
     for (size_t i = 0, e = elements.size(); i != e; ++i)
       ctxElements[i] = elements[i];
     return TemplateArgument(llvm::ArrayRef(ctxElements, elements.size()));
   }]>;
 }

clang/include/clang/AST/TemplateBase.h

enum ArgKind {
     /// in the Args struct.
     Pack
   };
 
 private:
   /// The kind of template argument we're storing.
 
   struct DA {
-    unsigned Kind;
+    unsigned Kind : 31;
+    unsigned IsDefaulted : 1;
     void *QT;
     ValueDecl *D;
   };
   struct I {
-    unsigned Kind;
+    unsigned Kind : 31;
+    unsigned IsDefaulted : 1;
     // We store a decomposed APSInt with the data allocated by ASTContext if
     // BitWidth > 64. The memory may be shared between multiple
     // TemplateArgument instances.
     unsigned BitWidth : 31;
     unsigned IsUnsigned : 1;
     union {
       /// Used to store the <= 64 bits integer value.
       uint64_t VAL;
 
       /// Used to store the >64 bits integer value.
       const uint64_t *pVal;
     };
     void *Type;
   };
   struct A {
-    unsigned Kind;
+    unsigned Kind : 31;
+    unsigned IsDefaulted : 1;
     unsigned NumArgs;
     const TemplateArgument *Args;
   };
   struct TA {
-    unsigned Kind;
+    unsigned Kind : 31;
+    unsigned IsDefaulted : 1;
     unsigned NumExpansions;
     void *Name;
   };
   struct TV {
-    unsigned Kind;
+    unsigned Kind : 31;
+    unsigned IsDefaulted : 1;
     uintptr_t V;
   };
   union {
     struct DA DeclArg;
     struct I Integer;
     struct A Args;
     struct TA TemplateArg;
     struct TV TypeOrValue;
   };
 
 public:
   /// Construct an empty, invalid template argument.
-  constexpr TemplateArgument() : TypeOrValue({Null, 0}) {}
+  constexpr TemplateArgument() : TypeOrValue({Null, 0, /* IsDefaulted */ 0}) {}
 
   /// Construct a template type argument.
-  TemplateArgument(QualType T, bool isNullPtr = false) {
+  TemplateArgument(QualType T, bool isNullPtr = false,
+                   bool IsDefaulted = false) {
     TypeOrValue.Kind = isNullPtr ? NullPtr : Type;
+    TypeOrValue.IsDefaulted = IsDefaulted;
     TypeOrValue.V = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
   }
 
   /// Construct a template argument that refers to a
   /// declaration, which is either an external declaration or a
   /// template declaration.
-  TemplateArgument(ValueDecl *D, QualType QT) {
+  TemplateArgument(ValueDecl *D, QualType QT, bool IsDefaulted = false) {
     assert(D && "Expected decl");
     DeclArg.Kind = Declaration;
+    DeclArg.IsDefaulted = IsDefaulted;
     DeclArg.QT = QT.getAsOpaquePtr();
     DeclArg.D = D;
   }
 
   /// Construct an integral constant template argument. The memory to
   /// store the value is allocated with Ctx.
-  TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value, QualType Type);
+  TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value, QualType Type,
+                   bool IsDefaulted = false);
 
   /// Construct an integral constant template argument with the same
   /// value as Other but a different type.
   TemplateArgument(const TemplateArgument &Other, QualType Type) {
     Integer = Other.Integer;
     Integer.Type = Type.getAsOpaquePtr();
   }
 
   /// Construct a template argument that is a template.
   ///
   /// This form of template argument is generally used for template template
   /// parameters. However, the template name could be a dependent template
   /// name that ends up being instantiated to a function template whose address
   /// is taken.
   ///
   /// \param Name The template name.
-  TemplateArgument(TemplateName Name) {
+  ///
+  /// \param IsDefaulted If 'true', implies that this TemplateArgument
+  /// corresponds to a default template parameter
+  TemplateArgument(TemplateName Name, bool IsDefaulted = false) {
     TemplateArg.Kind = Template;
+    TemplateArg.IsDefaulted = IsDefaulted;
     TemplateArg.Name = Name.getAsVoidPointer();
     TemplateArg.NumExpansions = 0;
   }
 
   /// Construct a template argument that is a template pack expansion.
   ///
   /// This form of template argument is generally used for template template
   /// parameters. However, the template name could be a dependent template
   /// name that ends up being instantiated to a function template whose address
   /// is taken.
   ///
   /// \param Name The template name.
   ///
   /// \param NumExpansions The number of expansions that will be generated by
   /// instantiating
-  TemplateArgument(TemplateName Name, std::optional<unsigned> NumExpansions) {
+  ///
+  /// \param IsDefaulted If 'true', implies that this TemplateArgument
+  /// corresponds to a default template parameter
+  TemplateArgument(TemplateName Name, std::optional<unsigned> NumExpansions,
+                   bool IsDefaulted = false) {
     TemplateArg.Kind = TemplateExpansion;
+    TemplateArg.IsDefaulted = IsDefaulted;
     TemplateArg.Name = Name.getAsVoidPointer();
     if (NumExpansions)
       TemplateArg.NumExpansions = *NumExpansions + 1;
     else
       TemplateArg.NumExpansions = 0;
   }
 
   /// Construct a template argument that is an expression.
   ///
   /// This form of template argument only occurs in template argument
   /// lists used for dependent types and for expression; it will not
   /// occur in a non-dependent, canonical template argument list.
-  TemplateArgument(Expr *E) {
+  TemplateArgument(Expr *E, bool IsDefaulted = false) {
     TypeOrValue.Kind = Expression;
+    TypeOrValue.IsDefaulted = IsDefaulted;
     TypeOrValue.V = reinterpret_cast<uintptr_t>(E);
   }
 
   /// Construct a template argument that is a template argument pack.
   ///
   /// We assume that storage for the template arguments provided
   /// outlives the TemplateArgument itself.
   explicit TemplateArgument(ArrayRef<TemplateArgument> Args) {
     this->Args.Kind = Pack;
+    this->Args.IsDefaulted = false;
     this->Args.Args = Args.data();
     this->Args.NumArgs = Args.size();
   }
 
-  TemplateArgument(TemplateName, bool) = delete;
-
   static TemplateArgument getEmptyPack() {
     return TemplateArgument(std::nullopt);
   }
 
   /// Create a new template argument pack by copying the given set of
   /// template arguments.
   static TemplateArgument CreatePackCopy(ASTContext &Context,
                                          ArrayRef<TemplateArgument> Args);
QualType getIntegralType() const {
     return QualType::getFromOpaquePtr(Integer.Type);
   }
 
   void setIntegralType(QualType T) {
     assert(getKind() == Integral && "Unexpected kind");
     Integer.Type = T.getAsOpaquePtr();
   }
 
+  /// Set to 'true' if this TemplateArgument corresponds to a
+  /// default template parameter.
+  void setIsDefaulted(bool v) { TypeOrValue.IsDefaulted = v; }
+
+  /// If returns 'true', this TemplateArgument corresponds to a
+  /// default template parameter.
+  bool getIsDefaulted() const { return (bool)TypeOrValue.IsDefaulted; }
+
   /// If this is a non-type template argument, get its type. Otherwise,
   /// returns a null QualType.
   QualType getNonTypeTemplateArgumentType() const;
 
   /// Retrieve the template argument as an expression.
   Expr *getAsExpr() const {
     assert(getKind() == Expression && "Unexpected kind");
     return reinterpret_cast<Expr *>(TypeOrValue.V);

clang/lib/AST/ASTContext.cpp

switch (Arg.getKind()) {
     case TemplateArgument::Null:
       return Arg;
 
     case TemplateArgument::Expression:
       return Arg;
 
     case TemplateArgument::Declaration: {
       auto *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
-      return TemplateArgument(D, getCanonicalType(Arg.getParamTypeForDecl()));
+      return TemplateArgument(D, getCanonicalType(Arg.getParamTypeForDecl()),
+                              Arg.getIsDefaulted());
     }
 
     case TemplateArgument::NullPtr:
       return TemplateArgument(getCanonicalType(Arg.getNullPtrType()),
-                              /*isNullPtr*/true);
+                              /*isNullPtr*/ true, Arg.getIsDefaulted());
 
     case TemplateArgument::Template:
-      return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()));
+      return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()),
+                              Arg.getIsDefaulted());
 
     case TemplateArgument::TemplateExpansion:
-      return TemplateArgument(getCanonicalTemplateName(
-                                         Arg.getAsTemplateOrTemplatePattern()),
-                              Arg.getNumTemplateExpansions());
+      return TemplateArgument(
+          getCanonicalTemplateName(Arg.getAsTemplateOrTemplatePattern()),
+          Arg.getNumTemplateExpansions(), Arg.getIsDefaulted());
 
     case TemplateArgument::Integral:
       return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType()));
 
     case TemplateArgument::Type:
-      return TemplateArgument(getCanonicalType(Arg.getAsType()));
+      return TemplateArgument(getCanonicalType(Arg.getAsType()),
+                              /*isNullPtr*/ false, Arg.getIsDefaulted());
 
     case TemplateArgument::Pack: {
       bool AnyNonCanonArgs = false;
       auto CanonArgs = ::getCanonicalTemplateArguments(
           *this, Arg.pack_elements(), AnyNonCanonArgs);
       if (!AnyNonCanonArgs)
         return Arg;
       return TemplateArgument::CreatePackCopy(const_cast<ASTContext &>(*this),

clang/lib/AST/TemplateBase.cpp

static bool needsAmpersandOnTemplateArg(QualType paramType, QualType argType) {
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // TemplateArgument Implementation
 //===----------------------------------------------------------------------===//
 
 TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value,
-                                   QualType Type) {
+                                   QualType Type, bool IsDefaulted) {
   Integer.Kind = Integral;
+  Integer.IsDefaulted = IsDefaulted;
   // Copy the APSInt value into our decomposed form.
   Integer.BitWidth = Value.getBitWidth();
   Integer.IsUnsigned = Value.isUnsigned();
   // If the value is large, we have to get additional memory from the ASTContext
   unsigned NumWords = Value.getNumWords();
   if (NumWords > 1) {
     void *Mem = Ctx.Allocate(NumWords * sizeof(uint64_t));
     std::memcpy(Mem, Value.getRawData(), NumWords * sizeof(uint64_t));

clang/lib/Sema/SemaTemplate.cpp

for (TemplateParameterList::iterator Param = Params->begin(),
     if (ArgIdx < NumArgs) {
       // Check the template argument we were given.
       if (CheckTemplateArgument(*Param, NewArgs[ArgIdx], Template, TemplateLoc,
                                 RAngleLoc, SugaredArgumentPack.size(),
                                 SugaredConverted, CanonicalConverted,
                                 CTAK_Specified))
         return true;
 
+      CanonicalConverted.back().setIsDefaulted(
+          clang::isSubstitutedDefaultArgument(
+              Context, NewArgs[ArgIdx].getArgument(), *Param,
+              CanonicalConverted, Params->getDepth()));
+
       bool PackExpansionIntoNonPack =
           NewArgs[ArgIdx].getArgument().isPackExpansion() &&
           (!(*Param)->isTemplateParameterPack() || getExpandedPackSize(*Param));
       if (PackExpansionIntoNonPack && (isa<TypeAliasTemplateDecl>(Template) ||
                                        isa<ConceptDecl>(Template))) {
         // Core issue 1430: we have a pack expansion as an argument to an
         // alias template, and it's not part of a parameter pack. This
         // can't be canonicalized, so reject it now.
if (Inst.isInvalid())
       return true;
 
     // Check the default template argument.
     if (CheckTemplateArgument(*Param, Arg, Template, TemplateLoc, RAngleLoc, 0,
                               SugaredConverted, CanonicalConverted,
                               CTAK_Specified))
       return true;
 
+    CanonicalConverted.back().setIsDefaulted(true);
+
     // Core issue 150 (assumed resolution): if this is a template template
     // parameter, keep track of the default template arguments from the
     // template definition.
     if (isTemplateTemplateParameter)
       NewArgs.addArgument(Arg);
 
     // Move to the next template parameter and argument.
     ++Param;

clang/unittests/AST/DeclTest.cpp

auto *AlignedArrayDelete = selectFirst<FunctionDecl>(
                 hasName("operator delete[]"), parameterCountIs(2),
                 hasParameter(0, hasType(pointerType(pointee(voidType())))),
                 hasParameter(1, hasType(enumDecl(hasName("std::align_val_t")))))
                 .bind("operator delete[]"),
             Ctx));
   ASSERT_TRUE(AlignedArrayDelete->getOwningModule());
   EXPECT_TRUE(AlignedArrayDelete->getOwningModule()->isGlobalModule());
 }
+
+TEST(Decl, TemplateArgumentDefaulted) {
+  llvm::Annotations Code(R"cpp(
+    template<typename T1, typename T2>
+    struct Alloc {};
+
+    template <typename T1,
+              typename T2 = double,
+              int      T3 = 42,
+              typename T4 = Alloc<T1, T2>>
+    struct Foo {
+    };
+
+    Foo<char, int, 42, Alloc<char, int>> X;
+  )cpp");
+
+  auto AST =
+      tooling::buildASTFromCodeWithArgs(Code.code(), /*Args=*/{"-std=c++20"});
+  ASTContext &Ctx = AST->getASTContext();
+
+  auto const *CTSD = selectFirst<ClassTemplateSpecializationDecl>(
+      "id",
+      match(classTemplateSpecializationDecl(hasName("Foo")).bind("id"), Ctx));
+  ASSERT_NE(CTSD, nullptr);
+  auto const &ArgList = CTSD->getTemplateArgs();
+
+  EXPECT_FALSE(ArgList.get(0).getIsDefaulted());
+  EXPECT_FALSE(ArgList.get(1).getIsDefaulted());
+  EXPECT_TRUE(ArgList.get(2).getIsDefaulted());
+  EXPECT_TRUE(ArgList.get(3).getIsDefaulted());
+}