Fix memleak in VarTemplateSpecializationDecl

[MitalAshok]

Summary

Replace TemplateArgumentListInfo with ASTTemplateArgumentListInfo
and convert between them in some places

[MitalAshok]

VarTemplateSpecializationDecl held a TemplateArgumentListInfo which holds a SmallVector<TemplateArgumentLoc, 8>, so in this test case https://github.com/llvm/llvm-project/blob/ee1cf1f64519c815025d962bdf9c9bb3d09d7699/clang/test/SemaCXX/has_unique_object_reps_bitint.cpp#L27 where there was a variable template with more than 8 template arguments, it leaked

[MitalAshok]

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

5561

The type of VarSpec->getTemplateArgsInfo() changed to ASTTemplateArgumentListInfo which is why the type of VisitVarTemplateSpecializationDecl needed to change

[MitalAshok]

Appears that more things need to be changed, I'll get that done soon

[browneee]

I was also looking into fixing this: https://reviews.llvm.org/D126944

I'm not yet sure if my changes are correct.

[aaron.ballman]

In D126937#3555243, @browneee wrote:

I was also looking into fixing this: https://reviews.llvm.org/D126944

I'm not yet sure if my changes are correct.

I did a review on https://reviews.llvm.org/D126944, but I'll let the two of you decide which review to move forward with rather than review them both in tandem. :-)

[aaron.ballman]

In D126937#3555731, @aaron.ballman wrote:

In D126937#3555243, @browneee wrote:

I was also looking into fixing this: https://reviews.llvm.org/D126944

I'm not yet sure if my changes are correct.

I did a review on https://reviews.llvm.org/D126944, but I'll let the two of you decide which review to move forward with rather than review them both in tandem. :-)

FYI, I've accepted that other review (we needed to get the leak fixed ASAP).

clang/include/clang/AST/DeclTemplate.h

class VarTemplateSpecializationDecl : public VarDecl,
   };
 
   /// Further info for explicit template specialization/instantiation.
   /// Does not apply to implicit specializations.
   ExplicitSpecializationInfo *ExplicitInfo = nullptr;
 
   /// The template arguments used to describe this specialization.
   const TemplateArgumentList *TemplateArgs;
-  TemplateArgumentListInfo TemplateArgsInfo;
+  const ASTTemplateArgumentListInfo *TemplateArgsInfo;
 
   /// The point where this template was instantiated (if any).
   SourceLocation PointOfInstantiation;
 
   /// The kind of specialization this declaration refers to.
   /// Really a value of type TemplateSpecializationKind.
   unsigned SpecializationKind : 3;
 
public:
   VarTemplateDecl *getSpecializedTemplate() const;
 
   /// Retrieve the template arguments of the variable template
   /// specialization.
   const TemplateArgumentList &getTemplateArgs() const { return *TemplateArgs; }
 
   // TODO: Always set this when creating the new specialization?
   void setTemplateArgsInfo(const TemplateArgumentListInfo &ArgsInfo);
+  void setTemplateArgsInfo(const ASTTemplateArgumentListInfo &ArgsInfo);
 
-  const TemplateArgumentListInfo &getTemplateArgsInfo() const {
-    return TemplateArgsInfo;
+  const ASTTemplateArgumentListInfo &getTemplateArgsInfo() const {
+    assert(TemplateArgsInfo &&
+           "Called getTemplateArgsInfo before setTemplateArgsInfo!");
+    return *TemplateArgsInfo;
   }
 
   /// Determine the kind of specialization that this
   /// declaration represents.
   TemplateSpecializationKind getSpecializationKind() const {
     return static_cast<TemplateSpecializationKind>(SpecializationKind);
   }
 

clang/include/clang/Sema/Template.h

#include "clang/AST/DeclNodes.inc"
 
     bool SubstQualifier(const DeclaratorDecl *OldDecl,
                         DeclaratorDecl *NewDecl);
     bool SubstQualifier(const TagDecl *OldDecl,
                         TagDecl *NewDecl);
 
     Decl *VisitVarTemplateSpecializationDecl(
         VarTemplateDecl *VarTemplate, VarDecl *FromVar,
-        const TemplateArgumentListInfo &TemplateArgsInfo,
+        const ASTTemplateArgumentListInfo &TemplateArgsInfo,
         ArrayRef<TemplateArgument> Converted,
         VarTemplateSpecializationDecl *PrevDecl = nullptr);
 
     Decl *InstantiateTypedefNameDecl(TypedefNameDecl *D, bool IsTypeAlias);
     ClassTemplatePartialSpecializationDecl *
     InstantiateClassTemplatePartialSpecialization(
                                               ClassTemplateDecl *ClassTemplate,
                            ClassTemplatePartialSpecializationDecl *PartialSpec);

clang/lib/AST/DeclTemplate.cpp

VarTemplateDecl *VarTemplateSpecializationDecl::getSpecializedTemplate() const {
   if (const auto *PartialSpec =
           SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
     return PartialSpec->PartialSpecialization->getSpecializedTemplate();
   return SpecializedTemplate.get<VarTemplateDecl *>();
 }
 
 void VarTemplateSpecializationDecl::setTemplateArgsInfo(
     const TemplateArgumentListInfo &ArgsInfo) {
-  TemplateArgsInfo.setLAngleLoc(ArgsInfo.getLAngleLoc());
-  TemplateArgsInfo.setRAngleLoc(ArgsInfo.getRAngleLoc());
-  for (const TemplateArgumentLoc &Loc : ArgsInfo.arguments())
-    TemplateArgsInfo.addArgument(Loc);
+  TemplateArgsInfo = ASTTemplateArgumentListInfo::Create(getASTContext(), ArgsInfo);
+}
+
+void VarTemplateSpecializationDecl::setTemplateArgsInfo(
+    const ASTTemplateArgumentListInfo &ArgsInfo) {
+  TemplateArgsInfo = &ArgsInfo;
 }
 
 //===----------------------------------------------------------------------===//
 // VarTemplatePartialSpecializationDecl Implementation
 //===----------------------------------------------------------------------===//
 
 void VarTemplatePartialSpecializationDecl::anchor() {}
 

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
 
   VarTemplateDecl *InstVarTemplate =
       cast_or_null<VarTemplateDecl>(SemaRef.FindInstantiatedDecl(
           D->getLocation(), VarTemplate, TemplateArgs));
   if (!InstVarTemplate)
     return nullptr;
 
   // Substitute the current template arguments.
-  const TemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
+  const ASTTemplateArgumentListInfo &TemplateArgsInfo = D->getTemplateArgsInfo();
   VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
   VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
 
   if (SemaRef.SubstTemplateArguments(TemplateArgsInfo.arguments(), TemplateArgs,
                                      VarTemplateArgsInfo))
     return nullptr;
 
   // Check that the template argument list is well-formed for this template.
Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
   bool Ignored;
   if (PrevDecl && SemaRef.CheckSpecializationInstantiationRedecl(
                       D->getLocation(), D->getSpecializationKind(), PrevDecl,
                       PrevDecl->getSpecializationKind(),
                       PrevDecl->getPointOfInstantiation(), Ignored))
     return nullptr;
 
   return VisitVarTemplateSpecializationDecl(
-      InstVarTemplate, D, VarTemplateArgsInfo, Converted, PrevDecl);
+      InstVarTemplate, D,
+      *ASTTemplateArgumentListInfo::Create(D->getASTContext(), VarTemplateArgsInfo), Converted, PrevDecl);
 }
 
 Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
     VarTemplateDecl *VarTemplate, VarDecl *D,
-    const TemplateArgumentListInfo &TemplateArgsInfo,
+    const ASTTemplateArgumentListInfo &TemplateArgsInfo,
     ArrayRef<TemplateArgument> Converted,
     VarTemplateSpecializationDecl *PrevDecl) {
 
   // Do substitution on the type of the declaration
   TypeSourceInfo *DI =
       SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
                         D->getTypeSpecStartLoc(), D->getDeclName());
   if (!DI)
VarTemplateSpecializationDecl *Sema::BuildVarTemplateInstantiation(
   MultiLevelTemplateArgumentList MultiLevelList(TemplateArgList);
   TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
                                         MultiLevelList);
 
   // TODO: Set LateAttrs and StartingScope ...
 
   return cast_or_null<VarTemplateSpecializationDecl>(
       Instantiator.VisitVarTemplateSpecializationDecl(
-          VarTemplate, FromVar, TemplateArgsInfo, Converted));
+          VarTemplate, FromVar,
+          *ASTTemplateArgumentListInfo::Create(getASTContext(), TemplateArgsInfo),
+          Converted));
 }
 
 /// Instantiates a variable template specialization by completing it
 /// with appropriate type information and initializer.
 VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl(
     VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
     const MultiLevelTemplateArgumentList &TemplateArgs) {
   assert(PatternDecl->isThisDeclarationADefinition() &&
void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
   } else if (Var->isStaticDataMember() &&
              Var->getLexicalDeclContext()->isRecord()) {
     // We need to instantiate the definition of a static data member template,
     // and all we have is the in-class declaration of it. Instantiate a separate
     // declaration of the definition.
     TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
                                           TemplateArgs);
     Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
         VarSpec->getSpecializedTemplate(), Def, VarSpec->getTemplateArgsInfo(),
         VarSpec->getTemplateArgs().asArray(), VarSpec));
     if (Var) {
       llvm::PointerUnion<VarTemplateDecl *,
                          VarTemplatePartialSpecializationDecl *> PatternPtr =
           VarSpec->getSpecializedTemplateOrPartial();
       if (VarTemplatePartialSpecializationDecl *Partial =
           PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
         cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(