[AST] Reduce the size of TemplateArgumentLocInfo.

[hokein]

Summary

allocate the underlying data of Template kind separately, this would reduce AST memory usage

• TemplateArgumentLocInfo 24 => 8 bytes
• TemplateARgumentLoc 48 => 32 bytes
• DynTypeNode 56 => 40 bytes

[sammccall]

Nit on the commit message: I think this is TemplateArgumentLoc 48 -> 32 bytes, and DynTypedNode 56 -> 40 bytes.

clang/include/clang/AST/TemplateBase.h

420–421

Can you use PointerUnion<Expr*, T*, TypeSourceInfo*>, and save even more of the boilerplate?

433

this is a no-op, and thus not worth stashing a pointer to Ctx for!

It also doesn't delete T, and it's probably best to do that even if it's (currently) a no-op

433

If you're going to destroy T in the destructor, then you can't have trivial copies, as the second one is pointing at deallocated memory.
(Well, apart from the fact that deallocation does nothing).

So I think we probably either want:

• allocation on ASTContext, trivial copies, no deallocation
• allocation on heap, copies reallocate
• allocation on heap using shared_ptr
• copies disallowed (but I think we rely on them being available)

435–440

this is not "heap allocation" in the usual sense - allocating in the context's slab allocator is cheaper but can't be deallocated.

Not sure how this compares to simply new T instead.

If not, then as with delete, I'd prefer new (Ctx) T (I think it's correct without as long as T is trivial, but less obvious)

[hokein]

address review comments:

• use PointerUnion
• keep the TemplateArgumentLocInfo trivial, allocate from allocator, no deallocation.

[hokein]

format

[hokein]

clang/include/clang/AST/TemplateBase.h

433

chose the first one.

[sammccall]

Looks good apart from a minor technical issue with the traits.

Would it be possible to compile some big file in LLVM (probably doesn't matter much which, Sema something?) and observe if there's a significant change in overall ASTContext size?

clang/include/clang/AST/TemplateBase.h

43

At first glance this is unsafe: you could have two different definitions of the same specialization in different files.

In fact it's OK, the default one can now never be instantiated, because Expr.h includes this file and so anyone that can see the definition can see this specialization.

But this is subtle/fragile: at least it needs to be spelled out explicitly in the comment.
I'd also suggest adding a static assert below the definition of Expr that it is compatible with this specialization (because it is sufficiently aligned).

(I can't think of a better alternative - use of PointerUnion is a win, partly *because* it validates the alignment)

430–432

the pattern here (use of Ctx for allocation although other variants don't) is unusual, maybe add a comment

[hokein]

address review comments.

[hokein]

Would it be possible to compile some big file in LLVM (probably doesn't matter much which, Sema something?) and observe if there's a significant change in overall ASTContext size?

~3% saving (measuring the ASTContext::.getASTAllocatedMemory)

	Before	After
SemaDecl.cpp	255.5 MB	247.5MB
SemaExpr.cpp	293.5 MB	283.5MB

clang/include/clang/AST/TemplateBase.h

43

yes, exactly.

do you have a better idea on how the static_assert should look like? The way I can think of is to add a new flag in this specialization, and use static_assert(PointerLikeTypeTraits<clang::Expr *>::flag, "...").

[rsmith]

clang/include/clang/AST/TemplateBase.h

43

This may be included from Expr.h right now, but really doesn't seem like the right header to hold this specialization. Perhaps we should consider adding something like an AST/ForwardDecls.h, containing forward declarations and specializations such as this one, and include that from Expr.h and from here?

421

If you're going to add more uses of the name T, we should rename it to something more descriptive. Maybe TemplateTemplateArgLocInfo or something like that?

435–441

I think this is just about complex enough to be worth moving to the .cpp file.

444

This is redundant (here and below): get does this assert for you.

[sammccall]

clang/include/clang/AST/Expr.h

963

I think this is it:

// PointerLikeTypeTraits is specialized so it can be used with a forward-decl of Expr.
// Verify that we got it right.
static_assert((1 << PointerLikeTypeTraits<Expr*>::NumLowBitsAvailable) == alignof(Expr), "PointerLikeTypeTraits<Expr*> assumes too much alignment");

(Or just % alignof(Expr) == 0 if you want a weaker condition)

clang/include/clang/AST/TemplateBase.h

43

I also had this thought but wasn't sure. @hokein maybe a trivial followup patch rather than inline here?

[hokein]

address review comments.

[hokein]

clang/include/clang/AST/Expr.h

963

Ah, thanks. alignof(Expr) is 8, I feel like comparing the Numbits directly seems more easy to understand.

clang/include/clang/AST/TemplateBase.h

43

that sounds good to me.

[sammccall]

Forgot to mention, 3% memory saving is huge, way more than I expected (was mostly just hoping for no regression).
Nice work!

clang/include/clang/AST/TemplateBase.h

431

I'd extend this comment a bit to explain why: "This case is unusually large and also rare, so we store the payload out-of-line."

clang/include/clang/AST/Expr.h

public:
   /// are not modified between E1 and E2 or the result my be invalid.
   static bool isSameComparisonOperand(const Expr* E1, const Expr* E2);
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() >= firstExprConstant &&
            T->getStmtClass() <= lastExprConstant;
   }
 };
+static_assert(llvm::PointerLikeTypeTraits<Expr *>::SpecializationForExpr,
+              "Specialization in TemplateBase.h must be seen here");
 
 //===----------------------------------------------------------------------===//
 // Wrapper Expressions.
 //===----------------------------------------------------------------------===//
 
 /// FullExpr - Represents a "full-expression" node.
 class FullExpr : public Expr {
 protected:

clang/include/clang/AST/TemplateBase.h

 //===- TemplateBase.h - Core classes for C++ templates ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file provides definitions which are common for all kinds of
 //  template representation.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_TEMPLATEBASE_H
 #define LLVM_CLANG_AST_TEMPLATEBASE_H
 
+#include "clang/AST/ASTContext.h"
 #include "clang/AST/DependenceFlags.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/TrailingObjects.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 
 namespace llvm {
 
 class FoldingSetNodeID;
 
+// Provide PointerLikeTypeTraits for clang::Expr*, this default one requires a
+// full definition of Expr, but this file only sees a forward del because of
+// the dependency.
+template <> struct PointerLikeTypeTraits<clang::Expr *> {
+  static inline void *getAsVoidPointer(clang::Expr *P) { return P; }
+  static inline clang::Expr *getFromVoidPointer(void *P) {
+    return static_cast<clang::Expr *>(P);
+  }
+
+  static constexpr int NumLowBitsAvailable = 2;
+  static constexpr bool SpecializationForExpr = true;
+};
+
 } // namespace llvm
 
 namespace clang {
 
 class ASTContext;
 class DiagnosticBuilder;
 class Expr;
 struct PrintingPolicy;
struct T {
     // FIXME: We'd like to just use the qualifier in the TemplateName,
     // but template arguments get canonicalized too quickly.
     NestedNameSpecifier *Qualifier;
     void *QualifierLocData;
     unsigned TemplateNameLoc;
     unsigned EllipsisLoc;
   };
 
-  union {
-    struct T Template;
-    Expr *Expression;
-    TypeSourceInfo *Declarator;
-  };
+  llvm::PointerUnion<T *, Expr *, TypeSourceInfo *> Pointer;
 
-public:
-  constexpr TemplateArgumentLocInfo() : Template({nullptr, nullptr, 0, 0}) {}
-
-  TemplateArgumentLocInfo(TypeSourceInfo *TInfo) : Declarator(TInfo) {}
+  T *getTemplate() const {
+    assert(Pointer.is<T *>());
+    return Pointer.get<T *>();
+  }
 
-  TemplateArgumentLocInfo(Expr *E) : Expression(E) {}
+public:
+  constexpr TemplateArgumentLocInfo() {}
+  TemplateArgumentLocInfo(TypeSourceInfo *Declarator) { Pointer = Declarator; }
 
-  TemplateArgumentLocInfo(NestedNameSpecifierLoc QualifierLoc,
+  TemplateArgumentLocInfo(Expr *E) { Pointer = E; }
+  // Ctx is used for allocation.
+  TemplateArgumentLocInfo(ASTContext &Ctx, NestedNameSpecifierLoc QualifierLoc,
                           SourceLocation TemplateNameLoc,
                           SourceLocation EllipsisLoc) {
-    Template.Qualifier = QualifierLoc.getNestedNameSpecifier();
-    Template.QualifierLocData = QualifierLoc.getOpaqueData();
-    Template.TemplateNameLoc = TemplateNameLoc.getRawEncoding();
-    Template.EllipsisLoc = EllipsisLoc.getRawEncoding();
+    T *Template = new (Ctx) T;
+    Template->Qualifier = QualifierLoc.getNestedNameSpecifier();
+    Template->QualifierLocData = QualifierLoc.getOpaqueData();
+    Template->TemplateNameLoc = TemplateNameLoc.getRawEncoding();
+    Template->EllipsisLoc = EllipsisLoc.getRawEncoding();
+    Pointer = Template;
   }
 
   TypeSourceInfo *getAsTypeSourceInfo() const {
-    return Declarator;
+    assert(Pointer.is<TypeSourceInfo *>());
+    return Pointer.get<TypeSourceInfo *>();
   }
 
   Expr *getAsExpr() const {
-    return Expression;
+    assert(Pointer.is<Expr *>());
+    return Pointer.get<Expr *>();
   }
 
   NestedNameSpecifierLoc getTemplateQualifierLoc() const {
-    return NestedNameSpecifierLoc(Template.Qualifier,
-                                  Template.QualifierLocData);
+    const auto *Template = getTemplate();
+    return NestedNameSpecifierLoc(Template->Qualifier,
+                                  Template->QualifierLocData);
   }
 
   SourceLocation getTemplateNameLoc() const {
-    return SourceLocation::getFromRawEncoding(Template.TemplateNameLoc);
+    return SourceLocation::getFromRawEncoding(getTemplate()->TemplateNameLoc);
   }
 
   SourceLocation getTemplateEllipsisLoc() const {
-    return SourceLocation::getFromRawEncoding(Template.EllipsisLoc);
+    return SourceLocation::getFromRawEncoding(getTemplate()->EllipsisLoc);
   }
 };
 
 /// Location wrapper for a TemplateArgument.  TemplateArgument is to
 /// TemplateArgumentLoc as Type is to TypeLoc.
 class TemplateArgumentLoc {
   TemplateArgument Argument;
   TemplateArgumentLocInfo LocInfo;
TemplateArgumentLoc(const TemplateArgument &Argument, Expr *E)
     // Permit any kind of template argument that can be represented with an
     // expression.
     assert(Argument.getKind() == TemplateArgument::NullPtr ||
            Argument.getKind() == TemplateArgument::Integral ||
            Argument.getKind() == TemplateArgument::Declaration ||
            Argument.getKind() == TemplateArgument::Expression);
   }
 
-  TemplateArgumentLoc(const TemplateArgument &Argument,
+  TemplateArgumentLoc(ASTContext &Ctx, const TemplateArgument &Argument,
                       NestedNameSpecifierLoc QualifierLoc,
                       SourceLocation TemplateNameLoc,
                       SourceLocation EllipsisLoc = SourceLocation())
       : Argument(Argument),
-        LocInfo(QualifierLoc, TemplateNameLoc, EllipsisLoc) {
+        LocInfo(Ctx, QualifierLoc, TemplateNameLoc, EllipsisLoc) {
     assert(Argument.getKind() == TemplateArgument::Template ||
            Argument.getKind() == TemplateArgument::TemplateExpansion);
   }
 
   /// - Fetches the primary location of the argument.
   SourceLocation getLocation() const {
     if (Argument.getKind() == TemplateArgument::Template ||
         Argument.getKind() == TemplateArgument::TemplateExpansion)

clang/lib/AST/ASTImporter.cpp

if (!ToTemplateQualifierLocOrErr)
       return ToTemplateQualifierLocOrErr.takeError();
     auto ToTemplateNameLocOrErr = import(FromInfo.getTemplateNameLoc());
     if (!ToTemplateNameLocOrErr)
       return ToTemplateNameLocOrErr.takeError();
     auto ToTemplateEllipsisLocOrErr =
         import(FromInfo.getTemplateEllipsisLoc());
     if (!ToTemplateEllipsisLocOrErr)
       return ToTemplateEllipsisLocOrErr.takeError();
-
     ToInfo = TemplateArgumentLocInfo(
-          *ToTemplateQualifierLocOrErr,
-          *ToTemplateNameLocOrErr,
-          *ToTemplateEllipsisLocOrErr);
+        Importer.getToContext(), *ToTemplateQualifierLocOrErr,
+        *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
   }
 
   return TemplateArgumentLoc(Arg, ToInfo);
 }
 
 template <>
 Expected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) {
   if (DG.isNull())

clang/lib/AST/TypeLoc.cpp

case TemplateArgument::TemplateExpansion: {
       NestedNameSpecifierLocBuilder Builder;
       TemplateName Template = Args[i].getAsTemplateOrTemplatePattern();
       if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
         Builder.MakeTrivial(Context, DTN->getQualifier(), Loc);
       else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
         Builder.MakeTrivial(Context, QTN->getQualifier(), Loc);
 
       ArgInfos[i] = TemplateArgumentLocInfo(
-          Builder.getWithLocInContext(Context), Loc,
+          Context, Builder.getWithLocInContext(Context), Loc,
           Args[i].getKind() == TemplateArgument::Template ? SourceLocation()
                                                           : Loc);
       break;
     }
 
     case TemplateArgument::Pack:
       ArgInfos[i] = TemplateArgumentLocInfo();
       break;

clang/lib/Sema/SemaTemplate.cpp

static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef,
 
   case ParsedTemplateArgument::Template: {
     TemplateName Template = Arg.getAsTemplate().get();
     TemplateArgument TArg;
     if (Arg.getEllipsisLoc().isValid())
       TArg = TemplateArgument(Template, Optional<unsigned int>());
     else
       TArg = Template;
-    return TemplateArgumentLoc(TArg,
-                               Arg.getScopeSpec().getWithLocInContext(
-                                                              SemaRef.Context),
-                               Arg.getLocation(),
-                               Arg.getEllipsisLoc());
+    return TemplateArgumentLoc(
+        SemaRef.Context, TArg,
+        Arg.getScopeSpec().getWithLocInContext(SemaRef.Context),
+        Arg.getLocation(), Arg.getEllipsisLoc());
   }
   }
 
   llvm_unreachable("Unhandled parsed template argument");
 }
 
 /// Translates template arguments as provided by the parser
 /// into template arguments used by semantic analysis.
TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
                                                     TemplateLoc,
                                                     RAngleLoc,
                                                     TempTempParm,
                                                     Converted,
                                                     QualifierLoc);
   if (TName.isNull())
     return TemplateArgumentLoc();
 
-  return TemplateArgumentLoc(TemplateArgument(TName),
-                TempTempParm->getDefaultArgument().getTemplateQualifierLoc(),
-                TempTempParm->getDefaultArgument().getTemplateNameLoc());
+  return TemplateArgumentLoc(
+      Context, TemplateArgument(TName),
 }
 
 /// Convert a template-argument that we parsed as a type into a template, if
 /// possible. C++ permits injected-class-names to perform dual service as
 /// template template arguments and as template type arguments.
-static TemplateArgumentLoc convertTypeTemplateArgumentToTemplate(TypeLoc TLoc) {
+static TemplateArgumentLoc
+convertTypeTemplateArgumentToTemplate(ASTContext &Context, TypeLoc TLoc) {
   // Extract and step over any surrounding nested-name-specifier.
   NestedNameSpecifierLoc QualLoc;
   if (auto ETLoc = TLoc.getAs<ElaboratedTypeLoc>()) {
     if (ETLoc.getTypePtr()->getKeyword() != ETK_None)
       return TemplateArgumentLoc();
 
     QualLoc = ETLoc.getQualifierLoc();
     TLoc = ETLoc.getNamedTypeLoc();
   }
-
   // If this type was written as an injected-class-name, it can be used as a
   // template template argument.
   if (auto InjLoc = TLoc.getAs<InjectedClassNameTypeLoc>())
-    return TemplateArgumentLoc(InjLoc.getTypePtr()->getTemplateName(),
+    return TemplateArgumentLoc(Context, InjLoc.getTypePtr()->getTemplateName(),
                                QualLoc, InjLoc.getNameLoc());
 
   // If this type was written as an injected-class-name, it may have been
   // converted to a RecordType during instantiation. If the RecordType is
   // *not* wrapped in a TemplateSpecializationType and denotes a class
   // template specialization, it must have come from an injected-class-name.
   if (auto RecLoc = TLoc.getAs<RecordTypeLoc>())
     if (auto *CTSD =
             dyn_cast<ClassTemplateSpecializationDecl>(RecLoc.getDecl()))
-      return TemplateArgumentLoc(TemplateName(CTSD->getSpecializedTemplate()),
+      return TemplateArgumentLoc(Context,
+                                 TemplateName(CTSD->getSpecializedTemplate()),
                                  QualLoc, RecLoc.getNameLoc());
 
   return TemplateArgumentLoc();
 }
 
 /// Check that the given template argument corresponds to the given
 /// template parameter.
 ///
bool Sema::CheckTemplateArgument(NamedDecl *Param,
   }
 
   // C++1z [temp.local]p1: (DR1004)
   //   When [the injected-class-name] is used [...] as a template-argument for
   //   a template template-parameter [...] it refers to the class template
   //   itself.
   if (Arg.getArgument().getKind() == TemplateArgument::Type) {
     TemplateArgumentLoc ConvertedArg = convertTypeTemplateArgumentToTemplate(
-        Arg.getTypeSourceInfo()->getTypeLoc());
+        Context, Arg.getTypeSourceInfo()->getTypeLoc());
     if (!ConvertedArg.getArgument().isNull())
       Arg = ConvertedArg;
   }
 
   switch (Arg.getArgument().getKind()) {
   case TemplateArgument::Null:
     llvm_unreachable("Should never see a NULL template argument here");
 
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
                                                        TemplateLoc,
                                                        RAngleLoc,
                                                        TempParm,
                                                        Converted,
                                                        QualifierLoc);
       if (Name.isNull())
         return true;
 
-      Arg = TemplateArgumentLoc(TemplateArgument(Name), QualifierLoc,
-                           TempParm->getDefaultArgument().getTemplateNameLoc());
+      Arg = TemplateArgumentLoc(
+          Context, TemplateArgument(Name), QualifierLoc,
     }
 
     // Introduce an instantiation record that describes where we are using
     // the default template argument. We're not actually instantiating a
     // template here, we just create this object to put a note into the
     // context stack.
     InstantiatingTemplate Inst(*this, RAngleLoc, Template, *Param, Converted,
                                SourceRange(TemplateLoc, RAngleLoc));

clang/lib/Sema/SemaTemplateDeduction.cpp

case TemplateArgument::TemplateExpansion: {
       TemplateName Template = Arg.getAsTemplateOrTemplatePattern();
       if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
         Builder.MakeTrivial(Context, DTN->getQualifier(), Loc);
       else if (QualifiedTemplateName *QTN =
                    Template.getAsQualifiedTemplateName())
         Builder.MakeTrivial(Context, QTN->getQualifier(), Loc);
 
       if (Arg.getKind() == TemplateArgument::Template)
-        return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context),
-                                   Loc);
+        return TemplateArgumentLoc(Context, Arg,
+                                   Builder.getWithLocInContext(Context), Loc);
 
-      return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context),
-                                 Loc, Loc);
+      return TemplateArgumentLoc(
+          Context, Arg, Builder.getWithLocInContext(Context), Loc, Loc);
     }
 
   case TemplateArgument::Expression:
     return TemplateArgumentLoc(Arg, Arg.getAsExpr());
 
   case TemplateArgument::Pack:
     return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
   }

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     QualifierLoc =
         SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
     TemplateName TName = SemaRef.SubstTemplateName(
         QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
         D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
     if (!TName.isNull())
       Param->setDefaultArgument(
           SemaRef.Context,
-          TemplateArgumentLoc(TemplateArgument(TName),
+          TemplateArgumentLoc(SemaRef.Context, TemplateArgument(TName),
                               D->getDefaultArgument().getTemplateQualifierLoc(),
                               D->getDefaultArgument().getTemplateNameLoc()));
   }
   Param->setAccess(AS_public);
   Param->setImplicit(D->isImplicit());
 
   // Introduce this template parameter's instantiation into the instantiation
   // scope.

clang/lib/Sema/SemaTemplateVariadic.cpp

case TemplateArgument::Expression: {
     Ellipsis = Expansion->getEllipsisLoc();
     NumExpansions = Expansion->getNumExpansions();
     return TemplateArgumentLoc(Pattern, Pattern);
   }
 
   case TemplateArgument::TemplateExpansion:
     Ellipsis = OrigLoc.getTemplateEllipsisLoc();
     NumExpansions = Argument.getNumTemplateExpansions();
-    return TemplateArgumentLoc(Argument.getPackExpansionPattern(),
+    return TemplateArgumentLoc(Context, Argument.getPackExpansionPattern(),
                                OrigLoc.getTemplateQualifierLoc(),
                                OrigLoc.getTemplateNameLoc());
 
   case TemplateArgument::Declaration:
   case TemplateArgument::NullPtr:
   case TemplateArgument::Template:
   case TemplateArgument::Integral:
   case TemplateArgument::Pack:

clang/lib/Sema/TreeTransform.h

case TemplateArgument::Expression: {
                                        EllipsisLoc, NumExpansions);
       if (Result.isInvalid())
         return TemplateArgumentLoc();
 
       return TemplateArgumentLoc(Result.get(), Result.get());
     }
 
     case TemplateArgument::Template:
-      return TemplateArgumentLoc(TemplateArgument(
-                                          Pattern.getArgument().getAsTemplate(),
-                                                  NumExpansions),
-                                 Pattern.getTemplateQualifierLoc(),
-                                 Pattern.getTemplateNameLoc(),
-                                 EllipsisLoc);
+      return TemplateArgumentLoc(
+          SemaRef.Context,
+          TemplateArgument(Pattern.getArgument().getAsTemplate(),
+          Pattern.getTemplateQualifierLoc(), Pattern.getTemplateNameLoc(),
 
     case TemplateArgument::Null:
     case TemplateArgument::Integral:
     case TemplateArgument::Declaration:
     case TemplateArgument::Pack:
     case TemplateArgument::TemplateExpansion:
     case TemplateArgument::NullPtr:
       llvm_unreachable("Pack expansion pattern has no parameter packs");
case TemplateArgument::Template: {
     CXXScopeSpec SS;
     SS.Adopt(QualifierLoc);
     TemplateName Template
       = getDerived().TransformTemplateName(SS, Arg.getAsTemplate(),
                                            Input.getTemplateNameLoc());
     if (Template.isNull())
       return true;
 
-    Output = TemplateArgumentLoc(TemplateArgument(Template), QualifierLoc,
-                                 Input.getTemplateNameLoc());
+    Output = TemplateArgumentLoc(SemaRef.Context, TemplateArgument(Template),
+                                 QualifierLoc, Input.getTemplateNameLoc());
     return false;
   }
 
   case TemplateArgument::TemplateExpansion:
     llvm_unreachable("Caller should expand pack expansions");
 
   case TemplateArgument::Expression: {
     // Template argument expressions are constant expressions.

clang/lib/Serialization/ASTReader.cpp

ASTRecordReader::readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind) {
   case TemplateArgument::Expression:
     return readExpr();
   case TemplateArgument::Type:
     return readTypeSourceInfo();
   case TemplateArgument::Template: {
     NestedNameSpecifierLoc QualifierLoc =
       readNestedNameSpecifierLoc();
     SourceLocation TemplateNameLoc = readSourceLocation();
-    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
-                                   SourceLocation());
+    return TemplateArgumentLocInfo(getASTContext(), QualifierLoc,
+                                   TemplateNameLoc, SourceLocation());
   }
   case TemplateArgument::TemplateExpansion: {
     NestedNameSpecifierLoc QualifierLoc = readNestedNameSpecifierLoc();
     SourceLocation TemplateNameLoc = readSourceLocation();
     SourceLocation EllipsisLoc = readSourceLocation();
-    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
-                                   EllipsisLoc);
+    return TemplateArgumentLocInfo(getASTContext(), QualifierLoc,
+                                   TemplateNameLoc, EllipsisLoc);
   }
   case TemplateArgument::Null:
   case TemplateArgument::Integral:
   case TemplateArgument::Declaration:
   case TemplateArgument::NullPtr:
   case TemplateArgument::Pack:
     // FIXME: Is this right?
     return TemplateArgumentLocInfo();