[clang] store sugared converted arguments on TemplateSpecializationType

[mizvekov]

Summary

WIP - Not ready for review

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

clang-tools-extra/clang-tidy/modernize/UseTransparentFunctorsCheck.cpp

const auto FunctorParentLoc =
           ->getAs<TemplateSpecializationTypeLoc>();
 
   if (!FunctorParentLoc)
     return;
 
   unsigned ArgNum = 0;
   const auto *FunctorParentType =
       FunctorParentLoc.getType()->castAs<TemplateSpecializationType>();
-  for (; ArgNum < FunctorParentType->getNumArgs(); ++ArgNum) {
-    const TemplateArgument &Arg = FunctorParentType->getArg(ArgNum);
+  for (; ArgNum < FunctorParentType->getSpecifiedArguments().size(); ++ArgNum) {
+    const TemplateArgument &Arg =
+        FunctorParentType->getSpecifiedArguments()[ArgNum];
     if (Arg.getKind() != TemplateArgument::Type)
       continue;
     QualType ParentArgType = Arg.getAsType();
     if (ParentArgType->isRecordType() &&
         ParentArgType->getAsCXXRecordDecl() ==
             Functor->getAsType()->getAsCXXRecordDecl())
       break;
   }
   // Functor is a default template argument.
-  if (ArgNum == FunctorParentType->getNumArgs())
+  if (ArgNum == FunctorParentType->getSpecifiedArguments().size())
     return;
   TemplateArgumentLoc FunctorLoc = FunctorParentLoc.getArgLoc(ArgNum);
   auto FunctorTypeLoc = getInnerTypeLocAs<TemplateSpecializationTypeLoc>(
       FunctorLoc.getTypeSourceInfo()->getTypeLoc());
   if (FunctorTypeLoc.isNull())
     return;
 
   SourceLocation ReportLoc = FunctorLoc.getLocation();

clang-tools-extra/clang-tidy/mpi/TypeMismatchCheck.cpp

isCXXComplexTypeMatching(const TemplateSpecializationType *const Template,
   static std::multimap<BuiltinType::Kind, StringRef> ComplexCXXMatches = {
       {BuiltinType::Float, "MPI_CXX_FLOAT_COMPLEX"},
       {BuiltinType::Double, "MPI_CXX_DOUBLE_COMPLEX"},
       {BuiltinType::LongDouble, "MPI_CXX_LONG_DOUBLE_COMPLEX"}};
 
   if (Template->getAsCXXRecordDecl()->getName() != "complex")
     return true;
 
-  const auto *Builtin =
-      Template->getArg(0).getAsType().getTypePtr()->getAs<BuiltinType>();
+  const auto *Builtin = Template->getSpecifiedArguments()[0]
+                            .getAsType()
+                            .getTypePtr()
+                            ->getAs<BuiltinType>();
 
   if (Builtin &&
       !isMPITypeMatching(ComplexCXXMatches, Builtin->getKind(), MPIDatatype)) {
     BufferTypeName =
         (llvm::Twine("complex<") + Builtin->getName(LO) + ">").str();
     return false;
   }
 

clang-tools-extra/clangd/HeuristicResolver.cpp

const Type *HeuristicResolver::getPointeeType(const Type *T) const {
   // because we discarded template arguments to perform lookup in the primary
   // template scope, so the return type would just have the form U* where U is a
   // template parameter type.
   // Instead, just handle the common case where the smart pointer type has the
   // form of SmartPtr<X, ...>, and assume X is the pointee type.
   auto *TST = T->getAs<TemplateSpecializationType>();
   if (!TST)
     return nullptr;
-  if (TST->getNumArgs() == 0)
+  if (TST->getSpecifiedArguments().size() == 0)
     return nullptr;
-  const TemplateArgument &FirstArg = TST->getArg(0);
+  const TemplateArgument &FirstArg = TST->getSpecifiedArguments()[0];
   if (FirstArg.getKind() != TemplateArgument::Type)
     return nullptr;
   return FirstArg.getAsType().getTypePtrOrNull();
 }
 
 std::vector<const NamedDecl *> HeuristicResolver::resolveMemberExpr(
     const CXXDependentScopeMemberExpr *ME) const {
   // If the expression has a qualifier, first try resolving the member

clang/include/clang/AST/ASTContext.h

QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl,
                                             unsigned Index,
                                             const TemplateArgument &ArgPack);
 
   QualType
   getTemplateTypeParmType(unsigned Depth, unsigned Index,
                           bool ParameterPack,
                           TemplateTypeParmDecl *ParmDecl = nullptr) const;
 
-  QualType getTemplateSpecializationType(TemplateName T,
-                                         ArrayRef<TemplateArgument> Args,
-                                         QualType Canon = QualType()) const;
+  QualType getTemplateSpecializationType(
+      TemplateName T, ArrayRef<TemplateArgument> SpecifiedArgs,
+      ArrayRef<TemplateArgument> SugaredConvertedArgs,
+      ArrayRef<TemplateArgument> CanonicalConvertedArgs,
 
-  QualType
-  getCanonicalTemplateSpecializationType(TemplateName T,
-                                         ArrayRef<TemplateArgument> Args) const;
-
-  QualType getTemplateSpecializationType(TemplateName T,
-                                         ArrayRef<TemplateArgumentLoc> Args,
-                                         QualType Canon = QualType()) const;
+  QualType getTemplateSpecializationType(
+      TemplateName T, ArrayRef<TemplateArgumentLoc> SpecifiedArgs,
+      ArrayRef<TemplateArgument> SugaredConvertedArgs,
+      ArrayRef<TemplateArgument> CanonicalConvertedArgs,
 
-  TypeSourceInfo *
-  getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc,
-                                    const TemplateArgumentListInfo &Args,
-                                    QualType Canon = QualType()) const;
+  TypeSourceInfo *getTemplateSpecializationTypeInfo(
+      TemplateName T, SourceLocation TLoc,
+      const TemplateArgumentListInfo &SpecifiedArgs,
+      ArrayRef<TemplateArgument> SugaredConvertedArgs,
+      ArrayRef<TemplateArgument> CanonicalConvertedArgs,
 
   QualType getParenType(QualType NamedType) const;
 
   QualType getMacroQualifiedType(QualType UnderlyingTy,
                                  const IdentifierInfo *MacroII) const;
 
   QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
                              NestedNameSpecifier *NNS, QualType NamedType,
                              TagDecl *OwnedTagDecl = nullptr) const;
   QualType getDependentNameType(ElaboratedTypeKeyword Keyword,
                                 NestedNameSpecifier *NNS,
                                 const IdentifierInfo *Name,
                                 QualType Canon = QualType()) const;
 
-  QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
-                                                  NestedNameSpecifier *NNS,
-                                                  const IdentifierInfo *Name,
-                                    const TemplateArgumentListInfo &Args) const;
+  QualType getDependentTemplateSpecializationType(
+      ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
+      const IdentifierInfo *Name, ArrayRef<TemplateArgumentLoc> Args) const;
   QualType getDependentTemplateSpecializationType(
       ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
       const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args) const;
 
   TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl);
 
   /// Get a template argument list with one argument per template parameter
   /// in a template parameter list, such as for the injected class name of
public:
   /// Retrieve the "canonical" template argument.
   ///
   /// The canonical template argument is the simplest template argument
   /// (which may be a type, value, expression, or declaration) that
   /// expresses the value of the argument.
   TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg)
     const;
 
+  /// Retrieve the "canonical" template argument list.
+  ///
+  /// Returns true if any arguments were non-canonical.
+  bool getCanonicalTemplateArguments(
+      ArrayRef<TemplateArgument> OrigArgs,
+      SmallVectorImpl<TemplateArgument> &CanonArgs) const;
+
   /// Type Query functions.  If the type is an instance of the specified class,
   /// return the Type pointer for the underlying maximally pretty type.  This
   /// is a member of ASTContext because this may need to do some amount of
   /// canonicalization, e.g. to move type qualifiers into the element type.
   const ArrayType *getAsArrayType(QualType T) const;
   const ConstantArrayType *getAsConstantArrayType(QualType T) const {
     return dyn_cast_or_null<ConstantArrayType>(getAsArrayType(T));
   }

clang/include/clang/AST/ASTNodeTraverser.h

void VisitBTFTagAttributedType(const BTFTagAttributedType *T) {
     Visit(T->getWrappedType());
   }
   void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *) {}
   void
   VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
     Visit(T->getArgumentPack());
   }
   void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
-    for (const auto &Arg : *T)
+    for (const auto &Arg : T->getSpecifiedArguments())
       Visit(Arg);
   }
   void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
     Visit(T->getPointeeType());
   }
   void VisitAtomicType(const AtomicType *T) { Visit(T->getValueType()); }
   void VisitPipeType(const PipeType *T) { Visit(T->getElementType()); }
   void VisitAdjustedType(const AdjustedType *T) { Visit(T->getOriginalType()); }

clang/include/clang/AST/RecursiveASTVisitor.h

public:
   bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc);
 
   /// Recursively visit a set of template arguments.
   /// This can be overridden by a subclass, but it's not expected that
   /// will be needed -- this visitor always dispatches to another.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
   // FIXME: take a TemplateArgumentLoc* (or TemplateArgumentListInfo) instead.
-  bool TraverseTemplateArguments(const TemplateArgument *Args,
-                                 unsigned NumArgs);
+  bool TraverseTemplateArguments(ArrayRef<TemplateArgument> Args);
 
   /// Recursively visit a base specifier. This can be overridden by a
   /// subclass.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
   bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &Base);
 
   /// Recursively visit a constructor initializer.  This
bool RecursiveASTVisitor<Derived>::TraverseTemplateArgument(
   case TemplateArgument::TemplateExpansion:
     return getDerived().TraverseTemplateName(
         Arg.getAsTemplateOrTemplatePattern());
 
   case TemplateArgument::Expression:
     return getDerived().TraverseStmt(Arg.getAsExpr());
 
   case TemplateArgument::Pack:
-    return getDerived().TraverseTemplateArguments(Arg.pack_begin(),
-                                                  Arg.pack_size());
+    return getDerived().TraverseTemplateArguments(Arg.pack_elements());
   }
 
   return true;
 }
 
 // FIXME: no template name location?
 // FIXME: no source locations for a template argument pack?
 template <typename Derived>
if (ArgLoc.getTemplateQualifierLoc())
           ArgLoc.getTemplateQualifierLoc()));
     return getDerived().TraverseTemplateName(
         Arg.getAsTemplateOrTemplatePattern());
 
   case TemplateArgument::Expression:
     return getDerived().TraverseStmt(ArgLoc.getSourceExpression());
 
   case TemplateArgument::Pack:
-    return getDerived().TraverseTemplateArguments(Arg.pack_begin(),
-                                                  Arg.pack_size());
+    return getDerived().TraverseTemplateArguments(Arg.pack_elements());
   }
 
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseTemplateArguments(
-    const TemplateArgument *Args, unsigned NumArgs) {
-  for (unsigned I = 0; I != NumArgs; ++I) {
-    TRY_TO(TraverseTemplateArgument(Args[I]));
-  }
+    ArrayRef<TemplateArgument> Args) {
+  for (const TemplateArgument &Arg : Args)
+    TRY_TO(TraverseTemplateArgument(Arg));
 
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseConstructorInitializer(
     CXXCtorInitializer *Init) {
   if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo())

 DEF_TRAVERSE_TYPE(UnaryTransformType, {
   TRY_TO(TraverseType(T->getBaseType()));
   TRY_TO(TraverseType(T->getUnderlyingType()));
 })
 
 DEF_TRAVERSE_TYPE(AutoType, {
   TRY_TO(TraverseType(T->getDeducedType()));
   if (T->isConstrained()) {
-    TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs()));
+    TRY_TO(TraverseTemplateArguments(T->getTypeConstraintArguments()));
   }
 })
 DEF_TRAVERSE_TYPE(DeducedTemplateSpecializationType, {
   TRY_TO(TraverseTemplateName(T->getTemplateName()));
   TRY_TO(TraverseType(T->getDeducedType()));
 })
 
 DEF_TRAVERSE_TYPE(RecordType, {})
 DEF_TRAVERSE_TYPE(EnumType, {})
 DEF_TRAVERSE_TYPE(TemplateTypeParmType, {})
 DEF_TRAVERSE_TYPE(SubstTemplateTypeParmType, {
   TRY_TO(TraverseType(T->getReplacementType()));
 })
 DEF_TRAVERSE_TYPE(SubstTemplateTypeParmPackType, {
   TRY_TO(TraverseTemplateArgument(T->getArgumentPack()));
 })
 
 DEF_TRAVERSE_TYPE(TemplateSpecializationType, {
   TRY_TO(TraverseTemplateName(T->getTemplateName()));
-  TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs()));
+  if (T->isCanonicalUnqualified())
+    TRY_TO(TraverseTemplateArguments(T->getConvertedArguments()));
+  else
+    TRY_TO(TraverseTemplateArguments(T->getSpecifiedArguments()));
 })
 
 DEF_TRAVERSE_TYPE(InjectedClassNameType, {})
 
 DEF_TRAVERSE_TYPE(AttributedType,
                   { TRY_TO(TraverseType(T->getModifiedType())); })
 
 DEF_TRAVERSE_TYPE(BTFTagAttributedType,
DEF_TRAVERSE_TYPE(ElaboratedType, {
   TRY_TO(TraverseType(T->getNamedType()));
 })
 
 DEF_TRAVERSE_TYPE(DependentNameType,
                   { TRY_TO(TraverseNestedNameSpecifier(T->getQualifier())); })
 
 DEF_TRAVERSE_TYPE(DependentTemplateSpecializationType, {
   TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
-  TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs()));
+  TRY_TO(TraverseTemplateArguments(T->template_arguments()));
 })
 
 DEF_TRAVERSE_TYPE(PackExpansionType, { TRY_TO(TraverseType(T->getPattern())); })
 
 DEF_TRAVERSE_TYPE(ObjCTypeParamType, {})
 
 DEF_TRAVERSE_TYPE(ObjCInterfaceType, {})
 

clang/include/clang/AST/TemplateBase.h

 
 public:
   TemplateArgumentListInfo() = default;
 
   TemplateArgumentListInfo(SourceLocation LAngleLoc,
                            SourceLocation RAngleLoc)
       : LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc) {}
 
+  TemplateArgumentListInfo(TemplateArgumentListInfo &&) = default;
+  TemplateArgumentListInfo &operator=(TemplateArgumentListInfo &&) = default;
+  TemplateArgumentListInfo(const TemplateArgumentListInfo &) = default;
+  TemplateArgumentListInfo &
+  operator=(const TemplateArgumentListInfo &) = default;
+
   // This can leak if used in an AST node, use ASTTemplateArgumentListInfo
   // instead.
   void *operator new(size_t bytes, ASTContext &C) = delete;
 
   SourceLocation getLAngleLoc() const { return LAngleLoc; }
   SourceLocation getRAngleLoc() const { return RAngleLoc; }
 
   void setLAngleLoc(SourceLocation Loc) { LAngleLoc = Loc; }
   void setRAngleLoc(SourceLocation Loc) { RAngleLoc = Loc; }
 
   unsigned size() const { return Arguments.size(); }
 
   const TemplateArgumentLoc *getArgumentArray() const {
     return Arguments.data();
   }
 
-  llvm::ArrayRef<TemplateArgumentLoc> arguments() const {
-    return Arguments;
-  }
+  llvm::ArrayRef<TemplateArgumentLoc> arguments() const { return Arguments; }
+  llvm::MutableArrayRef<TemplateArgumentLoc> arguments() { return Arguments; }
 
   const TemplateArgumentLoc &operator[](unsigned I) const {
     return Arguments[I];
   }
 
   TemplateArgumentLoc &operator[](unsigned I) {
     return Arguments[I];
   }
struct alignas(void *) ASTTemplateKWAndArgsInfo {
 
   void copyInto(const TemplateArgumentLoc *ArgArray,
                 TemplateArgumentListInfo &List) const;
 };
 
 const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                       const TemplateArgument &Arg);
 
-inline TemplateSpecializationType::iterator
-    TemplateSpecializationType::end() const {
-  return getArgs() + getNumArgs();
-}
-
-inline DependentTemplateSpecializationType::iterator
-    DependentTemplateSpecializationType::end() const {
-  return getArgs() + getNumArgs();
-}
-
-inline const TemplateArgument &
-    TemplateSpecializationType::getArg(unsigned Idx) const {
-  assert(Idx < getNumArgs() && "Template argument out of range");
-  return getArgs()[Idx];
-}
-
 inline const TemplateArgument &
     DependentTemplateSpecializationType::getArg(unsigned Idx) const {
   assert(Idx < getNumArgs() && "Template argument out of range");
   return getArgs()[Idx];
 }
 
 inline const TemplateArgument &AutoType::getArg(unsigned Idx) const {
   assert(Idx < getNumArgs() && "Template argument out of range");
   return getArgs()[Idx];
 }
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_TEMPLATEBASE_H

clang/include/clang/AST/Type.h

class TemplateSpecializationTypeBitfields {
 
     /// Whether this template specialization type is a substituted type alias.
     unsigned TypeAlias : 1;
 
     /// The number of template arguments named in this class template
     /// specialization, which is expected to be able to hold at least 1024
     /// according to [implimits]. However, as this limit is somewhat easy to
     /// hit with template metaprogramming we'd prefer to keep it as large
-    /// as possible. At the moment it has been left as a non-bitfield since
-    /// this type safely fits in 64 bits as an unsigned, so there is no reason
-    /// to introduce the performance impact of a bitfield.
-    unsigned NumArgs;
+    /// as possible.
+    unsigned NumSpecifiedArgs : 16;
+    unsigned NumConvertedArgs : 16;
   };
 
   class DependentTemplateSpecializationTypeBitfields {
     friend class DependentTemplateSpecializationType;
 
     unsigned : NumTypeBits;
     unsigned : NumTypeWithKeywordBits;
 
#include "clang/Basic/OpenCLExtensionTypes.def"
   /// Member-template getAs<specific type>'.  Look through sugar for
   /// an instance of \<specific type>.   This scheme will eventually
   /// replace the specific getAsXXXX methods above.
   ///
   /// There are some specializations of this member template listed
   /// immediately following this class.
   template <typename T> const T *getAs() const;
 
+  /// Look through sugar for an instance of TemplateSpecializationType which
+  /// is not a type alias.
+  const TemplateSpecializationType *
+  getAsNonAliasTemplateSpecializationType() const;
+
+  const TemplateSpecializationType *
+  castAsNonAliasTemplateSpecializationType() const {
+    auto TST = getAsNonAliasTemplateSpecializationType();
+    assert(TST && "not a TemplateSpecializationType");
+    return TST;
+  }
+
   /// Member-template getAsAdjusted<specific type>. Look through specific kinds
   /// of sugar (parens, attributes, etc) for an instance of \<specific type>.
   /// This is used when you need to walk over sugar nodes that represent some
   /// kind of type adjustment from a type that was written as a \<specific type>
   /// to another type that is still canonically a \<specific type>.
   template <typename T> const T *getAsAdjusted() const;
 
   /// A variant of getAs<> for array types which silently discards
class alignas(8) TemplateSpecializationType
   /// either a TemplateName::Template (in which case it is a
   /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
   /// TypeAliasTemplateDecl*), a
   /// TemplateName::SubstTemplateTemplateParmPack, or a
   /// TemplateName::SubstTemplateTemplateParm (in which case the
   /// replacement must, recursively, be one of these).
   TemplateName Template;
 
-  TemplateSpecializationType(TemplateName T,
-                             ArrayRef<TemplateArgument> Args,
-                             QualType Canon,
-                             QualType Aliased);
+  TemplateSpecializationType(TemplateName T, bool IsAlias,
+                             ArrayRef<TemplateArgument> SpecifiedArgs,
+                             ArrayRef<TemplateArgument> ConvertedArgs,
+                             QualType Underlying);
 
 public:
   /// Determine whether any of the given template arguments are dependent.
   ///
   /// The converted arguments should be supplied when known; whether an
   /// argument is dependent can depend on the conversions performed on it
   /// (for example, a 'const int' passed as a template argument might be
   /// dependent if the parameter is a reference but non-dependent if the
public:
   /// template<typename T, typename U, typename V> struct S;
   /// template<typename T, typename U> using A = S<T, int, U>;
   /// template<typename... Ts> struct X {
   ///   typedef A<Ts...> type; // not a type alias
   /// };
   /// \endcode
   bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }
 
-  /// Get the aliased type, if this is a specialization of a type alias
-  /// template.
-  QualType getAliasedType() const {
-    assert(isTypeAlias() && "not a type alias template specialization");
-    return *reinterpret_cast<const QualType*>(end());
-  }
-
-  using iterator = const TemplateArgument *;
-
-  iterator begin() const { return getArgs(); }
-  iterator end() const; // defined inline in TemplateBase.h
-
   /// Retrieve the name of the template that we are specializing.
   TemplateName getTemplateName() const { return Template; }
 
-  /// Retrieve the template arguments.
-  const TemplateArgument *getArgs() const {
-    return reinterpret_cast<const TemplateArgument *>(this + 1);
-  }
-
-  /// Retrieve the number of template arguments.
-  unsigned getNumArgs() const {
-    return TemplateSpecializationTypeBits.NumArgs;
+  ArrayRef<TemplateArgument> getSpecifiedArguments() const {
+    return {reinterpret_cast<const TemplateArgument *>(this + 1),
+            TemplateSpecializationTypeBits.NumSpecifiedArgs};
   }
 
-  /// Retrieve a specific template argument as a type.
-  /// \pre \c isArgType(Arg)
-  const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
+  ArrayRef<TemplateArgument> getConvertedArguments() const;
 
-  ArrayRef<TemplateArgument> template_arguments() const {
-    return {getArgs(), getNumArgs()};
-  }
+  /// Get the aliased type, if this is a specialization of a type alias
+  /// template.
+  QualType getAliasedType() const;
 
   bool isSugared() const {
     return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
   }
 
   QualType desugar() const {
     return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
   }
 
   void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
-    Profile(ID, Template, template_arguments(), Ctx);
-    if (isTypeAlias())
-      getAliasedType().Profile(ID);
+    Profile(ID, Template, getSpecifiedArguments(), getConvertedArguments(),
+            isSugared() ? desugar() : QualType(), Ctx);
   }
 
   static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
-                      ArrayRef<TemplateArgument> Args,
-                      const ASTContext &Context);
+                      ArrayRef<TemplateArgument> SpecifiedArgs,
+                      ArrayRef<TemplateArgument> ConvertedArgs,
+                      QualType Underlying, const ASTContext &Context);
 
   static bool classof(const Type *T) {
     return T->getTypeClass() == TemplateSpecialization;
   }
 };
 
 /// Print a template argument list, including the '<' and '>'
 /// enclosing the template arguments.

clang/include/clang/AST/TypeLoc.h

SourceLocation getRAngleLoc() const {
     return getLocalData()->RAngleLoc;
   }
 
   void setRAngleLoc(SourceLocation Loc) {
     getLocalData()->RAngleLoc = Loc;
   }
 
   unsigned getNumArgs() const {
-    return getTypePtr()->getNumArgs();
+    return getTypePtr()->getSpecifiedArguments().size();
   }
 
   void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI) {
     getArgInfos()[i] = AI;
   }
 
   TemplateArgumentLocInfo getArgLocInfo(unsigned i) const {
     return getArgInfos()[i];
   }
 
   TemplateArgumentLoc getArgLoc(unsigned i) const {
-    return TemplateArgumentLoc(getTypePtr()->getArg(i), getArgLocInfo(i));
+    return TemplateArgumentLoc(getTypePtr()->getSpecifiedArguments()[i],
+                               getArgLocInfo(i));
   }
 
   SourceLocation getTemplateNameLoc() const {
     return getLocalData()->NameLoc;
   }
 
   void setTemplateNameLoc(SourceLocation Loc) {
     getLocalData()->NameLoc = Loc;
else
       return SourceRange(getTemplateNameLoc(), getRAngleLoc());
   }
 
   void initializeLocal(ASTContext &Context, SourceLocation Loc) {
     setTemplateKeywordLoc(Loc);
     setTemplateNameLoc(Loc);
     setLAngleLoc(Loc);
     setRAngleLoc(Loc);
-    initializeArgLocs(Context, getNumArgs(), getTypePtr()->getArgs(),
+    initializeArgLocs(Context, getTypePtr()->getSpecifiedArguments(),
                       getArgInfos(), Loc);
   }
 
-  static void initializeArgLocs(ASTContext &Context, unsigned NumArgs,
-                                const TemplateArgument *Args,
+  static void initializeArgLocs(ASTContext &Context,
+                                ArrayRef<TemplateArgument> Args,
                                 TemplateArgumentLocInfo *ArgInfos,
                                 SourceLocation Loc);
 
   unsigned getExtraLocalDataSize() const {
     return getNumArgs() * sizeof(TemplateArgumentLocInfo);
   }
 
   unsigned getExtraLocalDataAlignment() const {

clang/include/clang/AST/TypeProperties.td

 
 let Class = TemplateSpecializationType in {
   def : Property<"dependent", Bool> {
     let Read = [{ node->isDependentType() }];
   }
   def : Property<"templateName", TemplateName> {
     let Read = [{ node->getTemplateName() }];
   }
-  def : Property<"templateArguments", Array<TemplateArgument>> {
-    let Read = [{ node->template_arguments() }];
+  def : Property<"specifiedArguments", Array<TemplateArgument>> {
+    let Read = [{ node->getSpecifiedArguments() }];
   }
-  def : Property<"underlyingType", Optional<QualType>> {
+  def : Property<"convertedArguments", Array<TemplateArgument>> {
+    let Read = [{ node->getConvertedArguments() }];
+  }
+  def : Property<"underlyingType", QualType> {
     let Read = [{
       node->isTypeAlias()
-        ? llvm::Optional<QualType>(node->getAliasedType())
+        ? node->getAliasedType()
         : node->isCanonicalUnqualified()
-            ? llvm::None
-            : llvm::Optional<QualType>(node->getCanonicalTypeInternal())
+            ? QualType() : node->getCanonicalTypeInternal()
     }];
   }
 
   def : Creator<[{
-    QualType result;
-    if (!underlyingType) {
-      result = ctx.getCanonicalTemplateSpecializationType(templateName,
-                                                          templateArguments);
-    } else {
-      result = ctx.getTemplateSpecializationType(templateName,
-                                                 templateArguments,
-                                                 *underlyingType);
-    }
+    QualType result = ctx.getTemplateSpecializationType(templateName,
+                                                        specifiedArguments,
+                                                        convertedArguments,
+                                                        /*CanonicalConvertedArguments=*/{},
+                                                        underlyingType);
     if (dependent)
       const_cast<Type *>(result.getTypePtr())
           ->addDependence(TypeDependence::DependentInstantiation);
     return result;
   }]>;
 }
 
 let Class = DependentTemplateSpecializationType in {

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

 // APIs for accessing the template argument list.
 inline ArrayRef<TemplateArgument>
 getTemplateSpecializationArgs(const ClassTemplateSpecializationDecl &D) {
   return D.getTemplateArgs().asArray();
 }
 
 inline ArrayRef<TemplateArgument>
 getTemplateSpecializationArgs(const TemplateSpecializationType &T) {
-  return llvm::makeArrayRef(T.getArgs(), T.getNumArgs());
+  return T.getSpecifiedArguments();
 }
 
 inline ArrayRef<TemplateArgument>
 getTemplateSpecializationArgs(const FunctionDecl &FD) {
   if (const auto* TemplateArgs = FD.getTemplateSpecializationArgs())
     return TemplateArgs->asArray();
   return ArrayRef<TemplateArgument>();
 }

clang/include/clang/Serialization/ASTRecordReader.h

public:
 
   /// Read a template parameter list, advancing Idx.
   TemplateParameterList *readTemplateParameterList();
 
   /// Read a template argument array, advancing Idx.
   void readTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
                                 bool Canonicalize = false);
 
+  /// Read a template argument list.
+  const TemplateArgumentList *
+  readTemplateArgumentList(bool Canonicalize = false);
+
   /// Read a UnresolvedSet structure, advancing Idx.
   void readUnresolvedSet(LazyASTUnresolvedSet &Set);
 
   /// Read a C++ base specifier, advancing Idx.
   CXXBaseSpecifier readCXXBaseSpecifier();
 
   /// Read a CXXCtorInitializer array, advancing Idx.
   CXXCtorInitializer **readCXXCtorInitializers();

clang/lib/AST/ASTContext.cpp

 }
 
 const ASTRecordLayout &
 ASTContext::getASTObjCImplementationLayout(
                                         const ObjCImplementationDecl *D) const {
   return getObjCLayout(D->getClassInterface(), D);
 }
 
-static bool
-getCanonicalTemplateArguments(const ASTContext &C,
-                              ArrayRef<TemplateArgument> OrigArgs,
-                              SmallVectorImpl<TemplateArgument> &CanonArgs) {
-  bool AnyNonCanonArgs = false;
-  unsigned NumArgs = OrigArgs.size();
-  CanonArgs.resize(NumArgs);
-  for (unsigned I = 0; I != NumArgs; ++I) {
-    const TemplateArgument &OrigArg = OrigArgs[I];
-    TemplateArgument &CanonArg = CanonArgs[I];
-    CanonArg = C.getCanonicalTemplateArgument(OrigArg);
-    if (!CanonArg.structurallyEquals(OrigArg))
-      AnyNonCanonArgs = true;
-  }
-  return AnyNonCanonArgs;
-}
-
 //===----------------------------------------------------------------------===//
 //                   Type creation/memoization methods
 //===----------------------------------------------------------------------===//
 
 QualType
 ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const {
   unsigned fastQuals = quals.getFastQualifiers();
   quals.removeFastQualifiers();
if (SubstTemplateTypeParmPackType *SubstParm =
           SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(SubstParm, 0);
 
   QualType Canon;
   {
     SmallVector<TemplateArgument, 8> Args(ArgPack.pack_size());
     TemplateArgument CanonArgPack = ArgPack;
     bool AnyNonCanonArgs =
-        getCanonicalTemplateArguments(*this, ArgPack.pack_elements(), Args);
+        getCanonicalTemplateArguments(ArgPack.pack_elements(), Args);
     if (AnyNonCanonArgs)
       CanonArgPack = TemplateArgument::CreatePackCopy(*this, Args);
     if (!AssociatedDecl->isCanonicalDecl() || AnyNonCanonArgs) {
       Canon = getSubstTemplateTypeParmPackType(
           AssociatedDecl->getCanonicalDecl(), Index, CanonArgPack);
       [[maybe_unused]] const auto *Nothing =
           SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
       assert(!Nothing);
TypeParm = new (*this, TypeAlignment)
       TemplateTypeParmType(Depth, Index, ParameterPack);
 
   Types.push_back(TypeParm);
   TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
 
   return QualType(TypeParm, 0);
 }
 
-TypeSourceInfo *
-ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name,
-                                              SourceLocation NameLoc,
-                                        const TemplateArgumentListInfo &Args,
-                                              QualType Underlying) const {
-  assert(!Name.getAsDependentTemplateName() &&
-         "No dependent template names here!");
-  QualType TST =
-      getTemplateSpecializationType(Name, Args.arguments(), Underlying);
+TypeSourceInfo *ASTContext::getTemplateSpecializationTypeInfo(
+    TemplateName Name, SourceLocation NameLoc,
+    const TemplateArgumentListInfo &SpecifiedArgs,
+    ArrayRef<TemplateArgument> SugaredConvertedArgs,
+    ArrayRef<TemplateArgument> CanonicalConvertedArgs,
+  QualType TST = getTemplateSpecializationType(
+      Name, SpecifiedArgs.arguments(), SugaredConvertedArgs,
+      CanonicalConvertedArgs, Underlying);
 
   TypeSourceInfo *DI = CreateTypeSourceInfo(TST);
   TemplateSpecializationTypeLoc TL =
       DI->getTypeLoc().castAs<TemplateSpecializationTypeLoc>();
   TL.setTemplateKeywordLoc(SourceLocation());
   TL.setTemplateNameLoc(NameLoc);
-  TL.setLAngleLoc(Args.getLAngleLoc());
-  TL.setRAngleLoc(Args.getRAngleLoc());
+  TL.setLAngleLoc(SpecifiedArgs.getLAngleLoc());
+  TL.setRAngleLoc(SpecifiedArgs.getRAngleLoc());
   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
-    TL.setArgLocInfo(i, Args[i].getLocInfo());
+    TL.setArgLocInfo(i, SpecifiedArgs[i].getLocInfo());
   return DI;
 }
 
-QualType
-ASTContext::getTemplateSpecializationType(TemplateName Template,
-                                          ArrayRef<TemplateArgumentLoc> Args,
-                                          QualType Underlying) const {
-  assert(!Template.getAsDependentTemplateName() &&
-         "No dependent template names here!");
-
-  SmallVector<TemplateArgument, 4> ArgVec;
-  ArgVec.reserve(Args.size());
-  for (const TemplateArgumentLoc &Arg : Args)
-    ArgVec.push_back(Arg.getArgument());
-
-  return getTemplateSpecializationType(Template, ArgVec, Underlying);
+QualType ASTContext::getTemplateSpecializationType(
+    TemplateName Template, ArrayRef<TemplateArgumentLoc> SpecifiedArgs,
+    ArrayRef<TemplateArgument> SugaredConvertedArgs,
+    ArrayRef<TemplateArgument> CanonicalConvertedArgs,
+  SmallVector<TemplateArgument, 4> SpecifiedArgVec;
+  SpecifiedArgVec.reserve(SpecifiedArgs.size());
+  for (const TemplateArgumentLoc &Arg : SpecifiedArgs)
+    SpecifiedArgVec.push_back(Arg.getArgument());
+
+  return getTemplateSpecializationType(Template, SpecifiedArgVec,
+                                       SugaredConvertedArgs,
+                                       CanonicalConvertedArgs, Underlying);
 }
 
 #ifndef NDEBUG
 static bool hasAnyPackExpansions(ArrayRef<TemplateArgument> Args) {
   for (const TemplateArgument &Arg : Args)
     if (Arg.isPackExpansion())
       return true;
 
   return true;
 }
 #endif
 
-QualType
-ASTContext::getTemplateSpecializationType(TemplateName Template,
-                                          ArrayRef<TemplateArgument> Args,
-                                          QualType Underlying) const {
+bool ASTContext::getCanonicalTemplateArguments(
+    ArrayRef<TemplateArgument> OrigArgs,
+    SmallVectorImpl<TemplateArgument> &CanonArgs) const {
+  bool AnyNonCanonArgs = false;
+  unsigned NumArgs = OrigArgs.size();
+  CanonArgs.resize(NumArgs);
+  for (unsigned I = 0; I != NumArgs; ++I) {
+    TemplateArgument OrigArg = OrigArgs[I];
+    TemplateArgument &CanonArg = CanonArgs[I];
+    CanonArg = getCanonicalTemplateArgument(OrigArg);
+    if (!CanonArg.structurallyEquals(OrigArg))
+      AnyNonCanonArgs = true;
+  }
+  return AnyNonCanonArgs;
+}
+
+QualType ASTContext::getTemplateSpecializationType(
+    TemplateName Template, ArrayRef<TemplateArgument> SpecifiedArgs,
+    ArrayRef<TemplateArgument> SugaredConvertedArgs,
+    ArrayRef<TemplateArgument> CanonicalConvertedArgs,
   assert(!Template.getAsDependentTemplateName() &&
          "No dependent template names here!");
+
+  bool AnyNonCanonArgs = false;
+  if (CanonicalConvertedArgs.size() != 0) {
+#ifndef NDEBUG
+    for (const TemplateArgument &A : CanonicalConvertedArgs)
+      assert(A.structurallyEquals(getCanonicalTemplateArgument(A)));
+#endif
+    if (SugaredConvertedArgs.empty()) {
+      SugaredConvertedArgs = CanonicalConvertedArgs;
+    } else {
+      assert(SugaredConvertedArgs.size() == CanonicalConvertedArgs.size());
+      for (unsigned I = 0; I < SugaredConvertedArgs.size(); ++I) {
+        if (!CanonicalConvertedArgs[I].structurallyEquals(
+                SugaredConvertedArgs[I])) {
+          AnyNonCanonArgs = true;
+          break;
+        }
+      }
+    }
+  } else {
+    assert(SugaredConvertedArgs.size() != 0);
+  }
+
   // Look through qualified template names.
   if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
     Template = QTN->getUnderlyingTemplate();
 
+  llvm::FoldingSetNodeID ID;
+  TemplateSpecializationType::Profile(ID, Template, SpecifiedArgs,
+                                      SugaredConvertedArgs, Underlying, *this);
+
+  void *InsertPos = nullptr;
+  if (auto *T = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
+    return QualType(T, 0);
+
   const auto *TD = Template.getAsTemplateDecl();
   bool IsTypeAlias = TD && TD->isTypeAlias();
-  QualType CanonType;
-  if (!Underlying.isNull())
-    CanonType = getCanonicalType(Underlying);
-  else {
-    // We can get here with an alias template when the specialization contains
-    // a pack expansion that does not match up with a parameter pack.
-    assert((!IsTypeAlias || hasAnyPackExpansions(Args)) &&
+  if (Underlying.isNull()) {
+    // We can get here with an alias template when the specialization
+    // contains a pack expansion that does not match up with a parameter
+    // pack.
+    assert((!IsTypeAlias || hasAnyPackExpansions(CanonicalConvertedArgs)) &&
            "Caller must compute aliased type");
     IsTypeAlias = false;
-    CanonType = getCanonicalTemplateSpecializationType(Template, Args);
-  }
-
-  // Allocate the (non-canonical) template specialization type, but don't
-  // try to unique it: these types typically have location information that
-  // we don't unique and don't want to lose.
-  void *Mem = Allocate(sizeof(TemplateSpecializationType) +
-                       sizeof(TemplateArgument) * Args.size() +
-                       (IsTypeAlias? sizeof(QualType) : 0),
-                       TypeAlignment);
-  auto *Spec
-    = new (Mem) TemplateSpecializationType(Template, Args, CanonType,
-                                         IsTypeAlias ? Underlying : QualType());
-
-  Types.push_back(Spec);
-  return QualType(Spec, 0);
-}
-
-QualType ASTContext::getCanonicalTemplateSpecializationType(
-    TemplateName Template, ArrayRef<TemplateArgument> Args) const {
-  assert(!Template.getAsDependentTemplateName() &&
-         "No dependent template names here!");
-
-  // Look through qualified template names.
-  if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
-    Template = TemplateName(QTN->getUnderlyingTemplate());
-
-  // Build the canonical template specialization type.
     TemplateName CanonTemplate = getCanonicalTemplateName(Template);
-  SmallVector<TemplateArgument, 4> CanonArgs;
-  ::getCanonicalTemplateArguments(*this, Args, CanonArgs);
 
-  // Determine whether this canonical template specialization type already
-  // exists.
-  llvm::FoldingSetNodeID ID;
-  TemplateSpecializationType::Profile(ID, CanonTemplate,
-                                      CanonArgs, *this);
+    SmallVector<TemplateArgument, 4> CanonArgsVec;
+    if (CanonicalConvertedArgs.size() == 0) {
+      AnyNonCanonArgs =
+          getCanonicalTemplateArguments(SugaredConvertedArgs, CanonArgsVec);
+      CanonicalConvertedArgs = CanonArgsVec;
+    }
 
-  void *InsertPos = nullptr;
-  TemplateSpecializationType *Spec
-    = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
+    if (AnyNonCanonArgs || !SpecifiedArgs.empty() ||
+        Template.getAsVoidPointer() != CanonTemplate.getAsVoidPointer()) {
+      Underlying = getTemplateSpecializationType(
+          CanonTemplate, ArrayRef<TemplateArgument>(), None,
+          CanonicalConvertedArgs, QualType());
+      assert(Underlying->isDependentType() &&
+             "Non-dependent template-id type must have a canonical type");
+      [[maybe_unused]] const auto *Found =
+          TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
+      assert(!Found);
+    }
+  }
 
-  if (!Spec) {
-    // Allocate a new canonical template specialization type.
-    void *Mem = Allocate((sizeof(TemplateSpecializationType) +
-                          sizeof(TemplateArgument) * CanonArgs.size()),
-                         TypeAlignment);
-    Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
-                                                CanonArgs,
-                                                QualType(), QualType());
-    Types.push_back(Spec);
-    TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
-  }
-
-  assert(Spec->isDependentType() &&
-         "Non-dependent template-id type must have a canonical type");
+  void *Mem =
+      Allocate(sizeof(TemplateSpecializationType) +
+                   sizeof(TemplateArgument) *
+                       (SpecifiedArgs.size() + SugaredConvertedArgs.size()) +
+                   (IsTypeAlias ? sizeof(QualType) : 0),
+  auto *Spec = new (Mem) TemplateSpecializationType(
+      Template, IsTypeAlias, SpecifiedArgs, SugaredConvertedArgs, Underlying);
+
   return QualType(Spec, 0);
 }
 
 QualType ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword,
                                        NestedNameSpecifier *NNS,
                                        QualType NamedType,
                                        TagDecl *OwnedTagDecl) const {
   llvm::FoldingSetNodeID ID;
if (T)
     return QualType(T, 0);
 
   T = new (*this, TypeAlignment) DependentNameType(Keyword, NNS, Name, Canon);
   Types.push_back(T);
   DependentNameTypes.InsertNode(T, InsertPos);
   return QualType(T, 0);
 }
 
-QualType
-ASTContext::getDependentTemplateSpecializationType(
-                                 ElaboratedTypeKeyword Keyword,
-                                 NestedNameSpecifier *NNS,
-                                 const IdentifierInfo *Name,
-                                 const TemplateArgumentListInfo &Args) const {
+QualType ASTContext::getDependentTemplateSpecializationType(
+    ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
+    const IdentifierInfo *Name, ArrayRef<TemplateArgumentLoc> Args) const {
   // TODO: avoid this copy
   SmallVector<TemplateArgument, 16> ArgCopy;
   for (unsigned I = 0, E = Args.size(); I != E; ++I)
     ArgCopy.push_back(Args[I].getArgument());
   return getDependentTemplateSpecializationType(Keyword, NNS, Name, ArgCopy);
 }
 
 QualType
if (T)
     return QualType(T, 0);
 
   NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
 
   ElaboratedTypeKeyword CanonKeyword = Keyword;
   if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
 
   SmallVector<TemplateArgument, 16> CanonArgs;
-  bool AnyNonCanonArgs =
-      ::getCanonicalTemplateArguments(*this, Args, CanonArgs);
+  bool AnyNonCanonArgs = getCanonicalTemplateArguments(Args, CanonArgs);
 
   QualType Canon;
   if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
     Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
                                                    Name,
                                                    CanonArgs);
 
     // Find the insert position again.
if (ObjCSuperType.isNull()) {
     ObjCSuperType = getTagDeclType(ObjCSuperTypeDecl);
   }
   return ObjCSuperType;
 }
 
 void ASTContext::setCFConstantStringType(QualType T) {
   const auto *TD = T->castAs<TypedefType>();
   CFConstantStringTypeDecl = cast<TypedefDecl>(TD->getDecl());
-  const auto *TagType =
-      CFConstantStringTypeDecl->getUnderlyingType()->castAs<RecordType>();
+  const auto *TagType = TD->castAs<RecordType>();
   CFConstantStringTagDecl = TagType->getDecl();
 }
 
 QualType ASTContext::getBlockDescriptorType() const {
   if (BlockDescriptorType)
     return getTagDeclType(BlockDescriptorType);
 
   RecordDecl *RD;
case Type::InjectedClassName: {
     return Ctx.getInjectedClassNameType(
         getCommonDeclChecked(IX->getDecl(), IY->getDecl()),
         Ctx.getCommonSugaredType(IX->getInjectedSpecializationType(),
                                  IY->getInjectedSpecializationType()));
   }
   case Type::TemplateSpecialization: {
     const auto *TX = cast<TemplateSpecializationType>(X),
                *TY = cast<TemplateSpecializationType>(Y);
-    auto As = getCommonTemplateArguments(Ctx, TX->template_arguments(),
-                                         TY->template_arguments());
+    auto SpecAs = getCommonTemplateArguments(Ctx, TX->getSpecifiedArguments(),
+                                             TY->getSpecifiedArguments());
+    auto ConvAs = getCommonTemplateArguments(Ctx, TX->getConvertedArguments(),
+                                             TY->getConvertedArguments());
     return Ctx.getTemplateSpecializationType(
         ::getCommonTemplateNameChecked(Ctx, TX->getTemplateName(),
                                        TY->getTemplateName()),
-        As, X->getCanonicalTypeInternal());
+        SpecAs, ConvAs, /*CanonicalConvertedArgs=*/{},
+        X->getCanonicalTypeInternal());
   }
   case Type::DependentName: {
     const auto *NX = cast<DependentNameType>(X),
                *NY = cast<DependentNameType>(Y);
     assert(NX->getIdentifier() == NY->getIdentifier());
     return Ctx.getDependentNameType(
         getCommonTypeKeyword(NX, NY), getCommonNNS(Ctx, NX, NY),
         NX->getIdentifier(), NX->getCanonicalTypeInternal());
#undef UNEXPECTED_TYPE
 
   case Type::TemplateSpecialization: {
     const auto *TX = cast<TemplateSpecializationType>(X),
                *TY = cast<TemplateSpecializationType>(Y);
     TemplateName CTN = ::getCommonTemplateName(Ctx, TX->getTemplateName(),
                                                TY->getTemplateName());
     if (!CTN.getAsVoidPointer())
       return QualType();
-    SmallVector<TemplateArgument, 8> Args;
-    if (getCommonTemplateArguments(Ctx, Args, TX->template_arguments(),
-                                   TY->template_arguments()))
+    SmallVector<TemplateArgument, 8> SpecAs;
+    if (getCommonTemplateArguments(Ctx, SpecAs, TX->getSpecifiedArguments(),
+                                   TY->getSpecifiedArguments()))
       return QualType();
-    return Ctx.getTemplateSpecializationType(CTN, Args,
+    auto ConvAs = getCommonTemplateArguments(Ctx, TX->getConvertedArguments(),
+                                             TY->getConvertedArguments());
+    return Ctx.getTemplateSpecializationType(CTN, SpecAs, ConvAs,
+                                             /*CanonicalConvertedArgs=*/{},
                                              Ctx.getQualifiedType(Underlying));
   }
   case Type::Typedef: {
     const auto *TX = cast<TypedefType>(X), *TY = cast<TypedefType>(Y);
     const TypedefNameDecl *CD = ::getCommonDecl(TX->getDecl(), TY->getDecl());
     if (!CD)
       return QualType();
     return Ctx.getTypedefType(CD, Ctx.getQualifiedType(Underlying));

clang/lib/AST/ASTDiagnostic.cpp

while (true) {
 
     // Desugar template specializations if any template argument should be
     // desugared.
     if (const TemplateSpecializationType *TST =
             dyn_cast<TemplateSpecializationType>(Ty)) {
       if (!TST->isTypeAlias()) {
         bool DesugarArgument = false;
         SmallVector<TemplateArgument, 4> Args;
-        for (unsigned I = 0, N = TST->getNumArgs(); I != N; ++I) {
-          const TemplateArgument &Arg = TST->getArg(I);
+        for (const TemplateArgument &Arg : TST->getSpecifiedArguments()) {
           if (Arg.getKind() == TemplateArgument::Type)
             Args.push_back(desugarForDiagnostic(Context, Arg.getAsType(),
                                                 DesugarArgument));
           else
             Args.push_back(Arg);
         }
 
         if (DesugarArgument) {
           ShouldAKA = true;
           QT = Context.getTemplateSpecializationType(
-              TST->getTemplateName(), Args, QT);
+              TST->getTemplateName(), Args, TST->getConvertedArguments(),
+              /*CanonicalConvertedArguments=*/None, QT);
         }
         break;
       }
     }
 
     if (const auto *AT = dyn_cast<ArrayType>(Ty)) {
       QualType ElementTy =
           desugarForDiagnostic(Context, AT->getElementType(), ShouldAKA);
struct InternalIterator {
       /// template argument.
       InternalIterator(const TemplateSpecializationType *TST)
           : TST(TST), Index(0), CurrentTA(nullptr), EndTA(nullptr) {
         if (!TST) return;
 
         if (isEnd()) return;
 
         // Set to first template argument.  If not a parameter pack, done.
-        TemplateArgument TA = TST->getArg(0);
+        TemplateArgument TA = TST->getSpecifiedArguments()[0];
         if (TA.getKind() != TemplateArgument::Pack) return;
 
         // Start looking into the parameter pack.
         CurrentTA = TA.pack_begin();
         EndTA = TA.pack_end();
 
         // Found a valid template argument.
         if (CurrentTA != EndTA) return;
 
         // Parameter pack is empty, use the increment to get to a valid
         // template argument.
         ++(*this);
       }
 
       /// Return true if the iterator is non-singular.
       bool isValid() const { return TST; }
 
       /// isEnd - Returns true if the iterator is one past the end.
       bool isEnd() const {
         assert(TST && "InternalIterator is invalid with a null TST.");
-        return Index >= TST->getNumArgs();
+        return Index >= TST->getSpecifiedArguments().size();
       }
 
       /// &operator++ - Increment the iterator to the next template argument.
       InternalIterator &operator++() {
         assert(TST && "InternalIterator is invalid with a null TST.");
         if (isEnd()) {
           return *this;
         }
 
         // If in a parameter pack, advance in the parameter pack.
         if (CurrentTA != EndTA) {
           ++CurrentTA;
           if (CurrentTA != EndTA)
             return *this;
         }
 
         // Loop until a template argument is found, or the end is reached.
         while (true) {
           // Advance to the next template argument.  Break if reached the end.
-          if (++Index == TST->getNumArgs())
+          if (++Index == TST->getSpecifiedArguments().size())
             break;
 
           // If the TemplateArgument is not a parameter pack, done.
-          TemplateArgument TA = TST->getArg(Index);
+          TemplateArgument TA = TST->getSpecifiedArguments()[Index];
           if (TA.getKind() != TemplateArgument::Pack)
             break;
 
           // Handle parameter packs.
           CurrentTA = TA.pack_begin();
           EndTA = TA.pack_end();
 
           // If the parameter pack is empty, try to advance again.
           if (CurrentTA != EndTA)
             break;
         }
         return *this;
       }
 
       /// operator* - Returns the appropriate TemplateArgument.
       reference operator*() const {
         assert(TST && "InternalIterator is invalid with a null TST.");
         assert(!isEnd() && "Index exceeds number of arguments.");
         if (CurrentTA == EndTA)
-          return TST->getArg(Index);
+          return TST->getSpecifiedArguments()[Index];
         else
           return *CurrentTA;
       }
 
       /// operator-> - Allow access to the underlying TemplateArgument.
       pointer operator->() const {
         assert(TST && "InternalIterator is invalid with a null TST.");
         return &operator*();
static const TemplateSpecializationType *GetTemplateSpecializationType(
 
     const ClassTemplateSpecializationDecl *CTSD =
         dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
 
     if (!CTSD)
       return nullptr;
 
     Ty = Context.getTemplateSpecializationType(
-             TemplateName(CTSD->getSpecializedTemplate()),
-             CTSD->getTemplateArgs().asArray(),
-             Ty.getLocalUnqualifiedType().getCanonicalType());
+        /*SpecifiedArgs=*/CTSD->getTemplateArgs().asArray(),
+        /*SugaredConvertedArgs=*/CTSD->getTemplateArgs().asArray(),
+        /*CanonicalConvertedArgs=*/None,
 
     return Ty->getAs<TemplateSpecializationType>();
   }
 
   /// Returns true if the DiffType is Type and false for Template.
   static bool OnlyPerformTypeDiff(ASTContext &Context, QualType FromType,
                                   QualType ToType,
                                   const TemplateSpecializationType *&FromArgTST,

clang/lib/AST/ASTImporter.cpp

Error ImportDefinition(
         EnumDecl *From, EnumDecl *To,
         ImportDefinitionKind Kind = IDK_Default);
     Error ImportDefinition(
         ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
         ImportDefinitionKind Kind = IDK_Default);
     Error ImportDefinition(
         ObjCProtocolDecl *From, ObjCProtocolDecl *To,
         ImportDefinitionKind Kind = IDK_Default);
-    Error ImportTemplateArguments(
-        const TemplateArgument *FromArgs, unsigned NumFromArgs,
+    Error ImportTemplateArguments(ArrayRef<TemplateArgument> FromArgs,
                                   SmallVectorImpl<TemplateArgument> &ToArgs);
     Expected<TemplateArgument>
     ImportTemplateArgument(const TemplateArgument &From);
 
     template <typename InContainerTy>
     Error ImportTemplateArgumentListInfo(
         const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo);
 
     template<typename InContainerTy>
ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
 
   FunctionTemplateAndArgsTy Result;
 
   auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
   if (Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate()))
     return std::move(Err);
 
   // Import template arguments.
-  auto TemplArgs = FTSInfo->TemplateArguments->asArray();
-  if (Error Err = ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
+  if (Error Err = ImportTemplateArguments(FTSInfo->TemplateArguments->asArray(),
                                           std::get<1>(Result)))
     return std::move(Err);
 
   return Result;
 }
 
 template <>
 Expected<TemplateParameterList *>
 ASTNodeImporter::import(TemplateParameterList *From) {
case TemplateArgument::Expression:
     if (ExpectedExpr ToExpr = import(From.getAsExpr()))
       return TemplateArgument(*ToExpr);
     else
       return ToExpr.takeError();
 
   case TemplateArgument::Pack: {
     SmallVector<TemplateArgument, 2> ToPack;
     ToPack.reserve(From.pack_size());
-    if (Error Err = ImportTemplateArguments(
-        From.pack_begin(), From.pack_size(), ToPack))
+    if (Error Err = ImportTemplateArguments(From.pack_elements(), ToPack))
       return std::move(Err);
 
     return TemplateArgument(
         llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
   }
   }
 
   llvm_unreachable("Invalid template argument kind");
ExpectedType ASTNodeImporter::VisitAutoType(const AutoType *T) {
   if (!ToDeducedTypeOrErr)
     return ToDeducedTypeOrErr.takeError();
 
   ExpectedDecl ToTypeConstraintConcept = import(T->getTypeConstraintConcept());
   if (!ToTypeConstraintConcept)
     return ToTypeConstraintConcept.takeError();
 
   SmallVector<TemplateArgument, 2> ToTemplateArgs;
-  ArrayRef<TemplateArgument> FromTemplateArgs = T->getTypeConstraintArguments();
-  if (Error Err = ImportTemplateArguments(FromTemplateArgs.data(),
-                                          FromTemplateArgs.size(),
+  if (Error Err = ImportTemplateArguments(T->getTypeConstraintArguments(),
                                           ToTemplateArgs))
     return std::move(Err);
 
   return Importer.getToContext().getAutoType(
       *ToDeducedTypeOrErr, T->getKeyword(), /*IsDependent*/false,
       /*IsPack=*/false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
       ToTemplateArgs);
 }

 }
 
 ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
                                        const TemplateSpecializationType *T) {
   auto ToTemplateOrErr = import(T->getTemplateName());
   if (!ToTemplateOrErr)
     return ToTemplateOrErr.takeError();
 
-  SmallVector<TemplateArgument, 2> ToTemplateArgs;
-  if (Error Err = ImportTemplateArguments(
-      T->getArgs(), T->getNumArgs(), ToTemplateArgs))
+  SmallVector<TemplateArgument, 2> ToSpecifiedArgs;
+  if (Error Err =
+          ImportTemplateArguments(T->getSpecifiedArguments(), ToSpecifiedArgs))
+    return std::move(Err);
+
+  SmallVector<TemplateArgument, 2> ToConvertedArgs;
+  if (Error Err =
+          ImportTemplateArguments(T->getConvertedArguments(), ToConvertedArgs))
     return std::move(Err);
 
   QualType ToCanonType;
   if (!T->isCanonicalUnqualified()) {
     QualType FromCanonType
       = Importer.getFromContext().getCanonicalType(QualType(T, 0));
     if (ExpectedType TyOrErr = import(FromCanonType))
       ToCanonType = *TyOrErr;
     else
       return TyOrErr.takeError();
   }
-  return Importer.getToContext().getTemplateSpecializationType(*ToTemplateOrErr,
-                                                               ToTemplateArgs,
-                                                               ToCanonType);
+  return Importer.getToContext().getTemplateSpecializationType(
+      *ToTemplateOrErr, ToSpecifiedArgs, ToConvertedArgs,
+      /*CanonicalConvertedArgs=*/None, ToCanonType);
 }
 
 ExpectedType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
   // Note: the qualifier in an ElaboratedType is optional.
   auto ToQualifierOrErr = import(T->getQualifier());
   if (!ToQualifierOrErr)
     return ToQualifierOrErr.takeError();
 
ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
   auto ToQualifierOrErr = import(T->getQualifier());
   if (!ToQualifierOrErr)
     return ToQualifierOrErr.takeError();
 
   IdentifierInfo *ToName = Importer.Import(T->getIdentifier());
 
   SmallVector<TemplateArgument, 2> ToPack;
   ToPack.reserve(T->getNumArgs());
-  if (Error Err = ImportTemplateArguments(
-      T->getArgs(), T->getNumArgs(), ToPack))
+  if (Error Err = ImportTemplateArguments(T->template_arguments(), ToPack))
     return std::move(Err);
 
   return Importer.getToContext().getDependentTemplateSpecializationType(
       T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
 }
 
 ExpectedType
 ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
Error ASTNodeImporter::ImportDefinition(
   // if the enumerator lists don't match.
   To->completeDefinition(*ToTypeOrErr, *ToPromotionTypeOrErr,
                          From->getNumPositiveBits(),
                          From->getNumNegativeBits());
   return Error::success();
 }
 
 Error ASTNodeImporter::ImportTemplateArguments(
-    const TemplateArgument *FromArgs, unsigned NumFromArgs,
+    ArrayRef<TemplateArgument> FromArgs,
     SmallVectorImpl<TemplateArgument> &ToArgs) {
-  for (unsigned I = 0; I != NumFromArgs; ++I) {
-    if (auto ToOrErr = import(FromArgs[I]))
+  for (const TemplateArgument &FromArg : FromArgs) {
+    if (auto ToOrErr = import(FromArg))
       ToArgs.push_back(*ToOrErr);
     else
       return ToOrErr.takeError();
   }
 
   return Error::success();
 }
 
if (T->getFoundDecl() &&
         isAncestorDeclContextOf(ParentDC, T->getFoundDecl()))
       return true;
 
     return {};
   }
 
   Optional<bool>
   VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
-    for (const auto &Arg : T->template_arguments())
+    for (const auto &Arg : T->getSpecifiedArguments())
       if (checkTemplateArgument(Arg))
         return true;
     // This type is a "sugar" to a record type, it can have a desugared type.
     return {};
   }
 
   Optional<bool> VisitConstantArrayType(const ConstantArrayType *T) {
     if (T->getSizeExpr() && isAncestorDeclContextOf(ParentDC, T->getSizeExpr()))
ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
 
   // Import the context of this declaration.
   DeclContext *DC, *LexicalDC;
   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
     return std::move(Err);
 
   // Import template arguments.
   SmallVector<TemplateArgument, 2> TemplateArgs;
-  if (Error Err = ImportTemplateArguments(
-      D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
+  if (Error Err =
+          ImportTemplateArguments(D->getTemplateArgs().asArray(), TemplateArgs))
     return std::move(Err);
   // Try to find an existing specialization with these template arguments and
   // template parameter list.
   void *InsertPos = nullptr;
   ClassTemplateSpecializationDecl *PrevDecl = nullptr;
   ClassTemplatePartialSpecializationDecl *PartialSpec =
             dyn_cast<ClassTemplatePartialSpecializationDecl>(D);
 
if (!BeginLocOrErr)
     return BeginLocOrErr.takeError();
 
   auto IdLocOrErr = import(D->getLocation());
   if (!IdLocOrErr)
     return IdLocOrErr.takeError();
 
   // Import template arguments.
   SmallVector<TemplateArgument, 2> TemplateArgs;
-  if (Error Err = ImportTemplateArguments(
-      D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
+  if (Error Err =
+          ImportTemplateArguments(D->getTemplateArgs().asArray(), TemplateArgs))
     return std::move(Err);
 
   // Try to find an existing specialization with these template arguments.
   void *InsertPos = nullptr;
   VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
       TemplateArgs, InsertPos);
   if (D2) {
     // We already have a variable template specialization with these template
if (Err)
     return std::move(Err);
 
   Optional<unsigned> Length;
   if (!E->isValueDependent())
     Length = E->getPackLength();
 
   SmallVector<TemplateArgument, 8> ToPartialArguments;
   if (E->isPartiallySubstituted()) {
-    if (Error Err = ImportTemplateArguments(
-        E->getPartialArguments().data(),
-        E->getPartialArguments().size(),
+    if (Error Err = ImportTemplateArguments(E->getPartialArguments(),
                                             ToPartialArguments))
       return std::move(Err);
   }
 
   return SizeOfPackExpr::Create(
       Importer.getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
       Length, ToPartialArguments);
 }
 

clang/lib/AST/ASTStructuralEquivalence.cpp

case TemplateName::UsingTemplate:
      // It is sufficient to check value of getAsTemplateDecl.
      break;
 
   }
 
   return true;
 }
 
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     ArrayRef<TemplateArgument> Args1,
+                                     ArrayRef<TemplateArgument> Args2);
+
 /// Determine whether two template arguments are equivalent.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      const TemplateArgument &Arg1,
                                      const TemplateArgument &Arg2) {
   if (Arg1.getKind() != Arg2.getKind())
     return false;
 
   switch (Arg1.getKind()) {
return IsStructurallyEquivalent(Context,
                                     Arg1.getAsTemplateOrTemplatePattern(),
                                     Arg2.getAsTemplateOrTemplatePattern());
 
   case TemplateArgument::Expression:
     return IsStructurallyEquivalent(Context, Arg1.getAsExpr(),
                                     Arg2.getAsExpr());
 
   case TemplateArgument::Pack:
-    if (Arg1.pack_size() != Arg2.pack_size())
-      return false;
+    return IsStructurallyEquivalent(Context, Arg1.pack_elements(),
+                                    Arg2.pack_elements());
+  }
 
-    for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
-      if (!IsStructurallyEquivalent(Context, Arg1.pack_begin()[I],
-                                    Arg2.pack_begin()[I]))
-        return false;
+  llvm_unreachable("Invalid template argument kind");
+}
+
+/// Determine whether two template argument lists are equivalent.
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     ArrayRef<TemplateArgument> Args1,
+                                     ArrayRef<TemplateArgument> Args2) {
+  if (Args1.size() != Args2.size())
 
-    return true;
-  }
+  for (unsigned I = 0, N = Args1.size(); I != N; ++I)
+    if (!IsStructurallyEquivalent(Context, Args1[I], Args2[I]))
+      return false;
 
-  llvm_unreachable("Invalid template argument kind");
-}
-
 /// Determine structural equivalence for the common part of array
 /// types.
 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                           const ArrayType *Array1,
                                           const ArrayType *Array2) {
   if (!IsStructurallyEquivalent(Context, Array1->getElementType(),
                                 Array2->getElementType()))
     return false;
if (!IsStructurallyEquivalent(Context, Auto1->getDeducedType(),
                                   Auto2->getDeducedType()))
       return false;
     if (Auto1->isConstrained() != Auto2->isConstrained())
       return false;
     if (Auto1->isConstrained()) {
       if (Auto1->getTypeConstraintConcept() !=
           Auto2->getTypeConstraintConcept())
         return false;
-      ArrayRef<TemplateArgument> Auto1Args =
-          Auto1->getTypeConstraintArguments();
-      ArrayRef<TemplateArgument> Auto2Args =
-          Auto2->getTypeConstraintArguments();
-      if (Auto1Args.size() != Auto2Args.size())
-        return false;
-      for (unsigned I = 0, N = Auto1Args.size(); I != N; ++I) {
-        if (!IsStructurallyEquivalent(Context, Auto1Args[I], Auto2Args[I]))
-          return false;
-      }
-    }
+      if (!IsStructurallyEquivalent(Context,
+                                    Auto1->getTypeConstraintArguments(),
+                                    Auto2->getTypeConstraintArguments()))
     break;
   }
 
   case Type::DeducedTemplateSpecialization: {
     const auto *DT1 = cast<DeducedTemplateSpecializationType>(T1);
     const auto *DT2 = cast<DeducedTemplateSpecializationType>(T2);
     if (!IsStructurallyEquivalent(Context, DT1->getTemplateName(),
                                   DT2->getTemplateName()))
static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::TemplateSpecialization: {
     const auto *Spec1 = cast<TemplateSpecializationType>(T1);
     const auto *Spec2 = cast<TemplateSpecializationType>(T2);
     if (!IsStructurallyEquivalent(Context, Spec1->getTemplateName(),
                                   Spec2->getTemplateName()))
       return false;
-    if (Spec1->getNumArgs() != Spec2->getNumArgs())
+    if (!IsStructurallyEquivalent(Context, Spec1->getSpecifiedArguments(),
+                                  Spec2->getSpecifiedArguments()))
       return false;
-    for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
-      if (!IsStructurallyEquivalent(Context, Spec1->getArg(I),
-                                    Spec2->getArg(I)))
-        return false;
-    }
+    if (!IsStructurallyEquivalent(Context, Spec1->getConvertedArguments(),
+                                  Spec2->getConvertedArguments()))
     break;
   }
 
   case Type::Elaborated: {
     const auto *Elab1 = cast<ElaboratedType>(T1);
     const auto *Elab2 = cast<ElaboratedType>(T2);
     // CHECKME: what if a keyword is ETK_None or ETK_typename ?
     if (Elab1->getKeyword() != Elab2->getKeyword())
case Type::DependentTemplateSpecialization: {
     const auto *Spec1 = cast<DependentTemplateSpecializationType>(T1);
     const auto *Spec2 = cast<DependentTemplateSpecializationType>(T2);
     if (!IsStructurallyEquivalent(Context, Spec1->getQualifier(),
                                   Spec2->getQualifier()))
       return false;
     if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
                                   Spec2->getIdentifier()))
       return false;
-    if (Spec1->getNumArgs() != Spec2->getNumArgs())
+    if (!IsStructurallyEquivalent(Context, Spec1->template_arguments(),
+                                  Spec2->template_arguments()))
       return false;
-    for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
-      if (!IsStructurallyEquivalent(Context, Spec1->getArg(I),
-                                    Spec2->getArg(I)))
-        return false;
-    }
     break;
   }
 
   case Type::PackExpansion:
     if (!IsStructurallyEquivalent(Context,
                                   cast<PackExpansionType>(T1)->getPattern(),
                                   cast<PackExpansionType>(T2)->getPattern()))
       return false;

clang/lib/AST/DeclPrinter.cpp

if (D->getIdentifier()) {
     Out << ' ' << *D;
 
     if (auto S = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
       ArrayRef<TemplateArgument> Args = S->getTemplateArgs().asArray();
       if (!Policy.PrintCanonicalTypes)
         if (const auto* TSI = S->getTypeAsWritten())
           if (const auto *TST =
                   dyn_cast<TemplateSpecializationType>(TSI->getType()))
-            Args = TST->template_arguments();
+            Args = TST->getSpecifiedArguments();
       printTemplateArguments(
           Args, S->getSpecializedTemplate()->getTemplateParameters());
     }
   }
 
   if (D->hasDefinition()) {
     if (D->hasAttr<FinalAttr>()) {
       Out << " final";

clang/lib/AST/DeclTemplate.cpp

ClassTemplateDecl::getInjectedClassNameSpecialization() {
   //  parameter of the class template. If the nth template parameter is a
   //  template parameter pack (14.5.3), the nth template argument is a pack
   //  expansion (14.5.3) whose pattern is the name of the template parameter
   //  pack.
   ASTContext &Context = getASTContext();
   TemplateParameterList *Params = getTemplateParameters();
   SmallVector<TemplateArgument, 16> TemplateArgs;
   Context.getInjectedTemplateArgs(Params, TemplateArgs);
-  CommonPtr->InjectedClassNameType
-    = Context.getTemplateSpecializationType(TemplateName(this),
-                                            TemplateArgs);
+  CommonPtr->InjectedClassNameType = Context.getTemplateSpecializationType(
+      TemplateName(this),
+      /*SpecifiedArgs=*/TemplateArgs,
+      /*SugaredConvertedArgs=*/TemplateArgs,
+      /*CanonicalConvertedArgs=*/None);
   return CommonPtr->InjectedClassNameType;
 }
 
 //===----------------------------------------------------------------------===//
 // TemplateTypeParm Allocation/Deallocation Method Implementations
 //===----------------------------------------------------------------------===//
 
 TemplateTypeParmDecl *

clang/lib/AST/ItaniumMangle.cpp

 void CXXNameMangler::manglePrefix(QualType type) {
   if (const auto *TST = type->getAs<TemplateSpecializationType>()) {
     if (!mangleSubstitution(QualType(TST, 0))) {
       mangleTemplatePrefix(TST->getTemplateName());
 
       // FIXME: GCC does not appear to mangle the template arguments when
       // the template in question is a dependent template name. Should we
       // emulate that badness?
-      mangleTemplateArgs(TST->getTemplateName(), TST->getArgs(),
-                         TST->getNumArgs());
+      auto Args = TST->isCanonicalUnqualified() ? TST->getConvertedArguments()
+                                                : TST->getSpecifiedArguments();
+      mangleTemplateArgs(TST->getTemplateName(), Args.begin(), Args.size());
       addSubstitution(QualType(TST, 0));
     }
   } else if (const auto *DTST =
                  type->getAs<DependentTemplateSpecializationType>()) {
     if (!mangleSubstitution(QualType(DTST, 0))) {
       TemplateName Template = getASTContext().getDependentTemplateName(
           DTST->getQualifier(), DTST->getIdentifier());
       mangleTemplatePrefix(Template);
case Type::TemplateSpecialization: {
     }
     case TemplateName::UsingTemplate: {
       TemplateDecl *TD = TN.getAsTemplateDecl();
       assert(TD && !isa<TemplateTemplateParmDecl>(TD));
       mangleSourceNameWithAbiTags(TD);
       break;
     }
     }
-
+    auto Args = TST->isCanonicalUnqualified() ? TST->getConvertedArguments()
+                                              : TST->getSpecifiedArguments();
     // Note: we don't pass in the template name here. We are mangling the
     // original source-level template arguments, so we shouldn't consider
     // conversions to the corresponding template parameter.
     // FIXME: Other compilers mangle partially-resolved template arguments in
     // unresolved-qualifier-levels.
-    mangleTemplateArgs(TemplateName(), TST->getArgs(), TST->getNumArgs());
+    mangleTemplateArgs(TemplateName(), Args.begin(), Args.size());
     break;
   }
 
   case Type::InjectedClassName:
     mangleSourceNameWithAbiTags(
         cast<InjectedClassNameType>(Ty)->getDecl());
     break;
 

 void CXXNameMangler::mangleType(const InjectedClassNameType *T) {
   // Mangle injected class name types as if the user had written the
   // specialization out fully.  It may not actually be possible to see
   // this mangling, though.
   mangleType(T->getInjectedSpecializationType());
 }
 
 void CXXNameMangler::mangleType(const TemplateSpecializationType *T) {
+  auto Args = T->isCanonicalUnqualified() ? T->getConvertedArguments()
+                                          : T->getSpecifiedArguments();
   if (TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl()) {
-    mangleTemplateName(TD, T->getArgs(), T->getNumArgs());
+    mangleTemplateName(TD, Args.begin(), Args.size());
   } else {
     if (mangleSubstitution(QualType(T, 0)))
       return;
 
     mangleTemplatePrefix(T->getTemplateName());
 
     // FIXME: GCC does not appear to mangle the template arguments when
     // the template in question is a dependent template name. Should we
     // emulate that badness?
-    mangleTemplateArgs(T->getTemplateName(), T->getArgs(), T->getNumArgs());
+    mangleTemplateArgs(T->getTemplateName(), Args.begin(), Args.size());
     addSubstitution(QualType(T, 0));
   }
 }
 
 void CXXNameMangler::mangleType(const DependentNameType *T) {
   // Proposal by cxx-abi-dev, 2014-03-26
   // <class-enum-type> ::= <name>    # non-dependent or dependent type name or
   //                                 # dependent elaborated type specifier using

clang/lib/AST/NestedNameSpecifier.cpp

case TypeSpec: {
     if (const TemplateSpecializationType *SpecType
           = dyn_cast<TemplateSpecializationType>(T)) {
       // Print the template name without its corresponding
       // nested-name-specifier.
       SpecType->getTemplateName().print(OS, InnerPolicy,
                                         TemplateName::Qualified::None);
 
       // Print the template argument list.
-      printTemplateArgumentList(OS, SpecType->template_arguments(),
+      printTemplateArgumentList(OS, SpecType->getSpecifiedArguments(),
                                 InnerPolicy);
     } else if (const auto *DepSpecType =
                    dyn_cast<DependentTemplateSpecializationType>(T)) {
       // Print the template name without its corresponding
       // nested-name-specifier.
       OS << DepSpecType->getIdentifier()->getName();
       // Print the template argument list.
       printTemplateArgumentList(OS, DepSpecType->template_arguments(),

clang/lib/AST/ODRHash.cpp

void VisitTagType(const TagType *T) {
     AddDecl(T->getDecl());
     VisitType(T);
   }
 
   void VisitRecordType(const RecordType *T) { VisitTagType(T); }
   void VisitEnumType(const EnumType *T) { VisitTagType(T); }
 
   void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
-    ID.AddInteger(T->getNumArgs());
-    for (const auto &TA : T->template_arguments()) {
+    ID.AddInteger(T->getSpecifiedArguments().size());
+    for (const auto &TA : T->getSpecifiedArguments()) {
       Hash.AddTemplateArgument(TA);
     }
     Hash.AddTemplateName(T->getTemplateName());
     VisitType(T);
   }
 
   void VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
     ID.AddInteger(T->getDepth());

clang/lib/AST/QualTypeNames.cpp

static const Type *getFullyQualifiedTemplateType(const ASTContext &Ctx,
   // definitions. Therefore we shouldn't encounter them at the end of
   // a translation unit. If we do, the caller has made an error.
   assert(!isa<DependentTemplateSpecializationType>(TypePtr));
   // In case of template specializations, iterate over the arguments
   // and fully qualify them as well.
   if (const auto *TST = dyn_cast<const TemplateSpecializationType>(TypePtr)) {
     bool MightHaveChanged = false;
     SmallVector<TemplateArgument, 4> FQArgs;
-    for (TemplateSpecializationType::iterator I = TST->begin(), E = TST->end();
-         I != E; ++I) {
-      // Cheap to copy and potentially modified by
-      // getFullyQualifedTemplateArgument.
-      TemplateArgument Arg(*I);
+    for (TemplateArgument Arg : TST->getSpecifiedArguments()) {
       MightHaveChanged |= getFullyQualifiedTemplateArgument(
           Ctx, Arg, WithGlobalNsPrefix);
       FQArgs.push_back(Arg);
     }
 
     // If a fully qualified arg is different from the unqualified arg,
     // allocate new type in the AST.
     if (MightHaveChanged) {
       QualType QT = Ctx.getTemplateSpecializationType(
-          TST->getTemplateName(), FQArgs,
-          TST->getCanonicalTypeInternal());
+          TST->getTemplateName(), FQArgs, TST->getConvertedArguments(),
+          /*CanonicalConvertedArgs=*/None, TST->getCanonicalTypeInternal());
       // getTemplateSpecializationType returns a fully qualified
       // version of the specialization itself, so no need to qualify
       // it.
       return QT.getTypePtr();
     }
   } else if (const auto *TSTRecord = dyn_cast<const RecordType>(TypePtr)) {
     // We are asked to fully qualify and we have a Record Type,
     // which can point to a template instantiation with no sugar in any of
if (const auto *TSTDecl =
         FQArgs.push_back(Arg);
       }
 
       // If a fully qualified arg is different from the unqualified arg,
       // allocate new type in the AST.
       if (MightHaveChanged) {
         TemplateName TN(TSTDecl->getSpecializedTemplate());
         QualType QT = Ctx.getTemplateSpecializationType(
-            TN, FQArgs,
+            TN, FQArgs, FQArgs,
+            /*CanonicalConvertedArgs=*/None,
             TSTRecord->getCanonicalTypeInternal());
         // getTemplateSpecializationType returns a fully qualified
         // version of the specialization itself, so no need to qualify
         // it.
         return QT.getTypePtr();
       }
     }
   }

clang/lib/AST/Type.cpp

TagDecl *Type::getAsTagDecl() const {
   if (const auto *TT = getAs<TagType>())
     return TT->getDecl();
   if (const auto *Injected = getAs<InjectedClassNameType>())
     return Injected->getDecl();
 
   return nullptr;
 }
 
+const TemplateSpecializationType *
+Type::getAsNonAliasTemplateSpecializationType() const {
+  for (auto T = this; /**/; /**/) {
+    const TemplateSpecializationType *TST =
+        T->getAs<TemplateSpecializationType>();
+    if (!TST || !TST->isTypeAlias())
+      return TST;
+    T = TST->desugar().getTypePtr();
+  }
+}
+
 bool Type::hasAttr(attr::Kind AK) const {
   const Type *Cur = this;
   while (const auto *AT = Cur->getAs<AttributedType>()) {
     if (AT->getAttrKind() == AK)
       return true;
     Cur = AT->getEquivalentType().getTypePtr();
   }
   return false;
bool TemplateSpecializationType::anyInstantiationDependentTemplateArguments(
   for (const TemplateArgumentLoc &ArgLoc : Args) {
     if (ArgLoc.getArgument().isInstantiationDependent())
       return true;
   }
   return false;
 }
 
 TemplateSpecializationType::TemplateSpecializationType(
-    TemplateName T, ArrayRef<TemplateArgument> Args, QualType Canon,
-    QualType AliasedType)
-    : Type(TemplateSpecialization, Canon.isNull() ? QualType(this, 0) : Canon,
-           (Canon.isNull()
+    TemplateName T, bool IsAlias, ArrayRef<TemplateArgument> SpecifiedArgs,
+    ArrayRef<TemplateArgument> ConvertedArgs, QualType Underlying)
+    : Type(TemplateSpecialization,
+           Underlying.isNull() ? QualType(this, 0)
+                               : Underlying.getCanonicalType(),
+           (Underlying.isNull()
                 ? TypeDependence::DependentInstantiation
-                : toSemanticDependence(Canon->getDependence())) |
+                : toSemanticDependence(Underlying->getDependence())) |
                (toTypeDependence(T.getDependence()) &
                 TypeDependence::UnexpandedPack)),
       Template(T) {
-  TemplateSpecializationTypeBits.NumArgs = Args.size();
-  TemplateSpecializationTypeBits.TypeAlias = !AliasedType.isNull();
+  TemplateSpecializationTypeBits.NumSpecifiedArgs = SpecifiedArgs.size();
+  TemplateSpecializationTypeBits.NumConvertedArgs = ConvertedArgs.size();
+  TemplateSpecializationTypeBits.TypeAlias = IsAlias;
 
   assert(!T.getAsDependentTemplateName() &&
          "Use DependentTemplateSpecializationType for dependent template-name");
   assert((T.getKind() == TemplateName::Template ||
           T.getKind() == TemplateName::SubstTemplateTemplateParm ||
           T.getKind() == TemplateName::SubstTemplateTemplateParmPack ||
           T.getKind() == TemplateName::UsingTemplate) &&
          "Unexpected template name for TemplateSpecializationType");
 
-  auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1);
-  for (const TemplateArgument &Arg : Args) {
+  auto initArgs = [this](ArrayRef<TemplateArgument> Out,
+                         ArrayRef<TemplateArgument> In) {
+    auto *Args = const_cast<TemplateArgument *>(Out.data());
+    for (const TemplateArgument &Arg : In) {
       // Update instantiation-dependent, variably-modified, and error bits.
       // If the canonical type exists and is non-dependent, the template
       // specialization type can be non-dependent even if one of the type
       // arguments is. Given:
       //   template<typename T> using U = int;
       // U<T> is always non-dependent, irrespective of the type T.
       // However, U<Ts> contains an unexpanded parameter pack, even though
       // its expansion (and thus its desugared type) doesn't.
       addDependence(toTypeDependence(Arg.getDependence()) &
                     ~TypeDependence::Dependent);
       if (Arg.getKind() == TemplateArgument::Type)
         addDependence(Arg.getAsType()->getDependence() &
                       TypeDependence::VariablyModified);
-    new (TemplateArgs++) TemplateArgument(Arg);
+      new (Args++) TemplateArgument(Arg);
     }
+  };
+
+  initArgs(getSpecifiedArguments(), SpecifiedArgs);
+  initArgs(getConvertedArguments(), ConvertedArgs);
 
   // Store the aliased type if this is a type alias template specialization.
-  if (isTypeAlias()) {
-    auto *Begin = reinterpret_cast<TemplateArgument *>(this + 1);
-    *reinterpret_cast<QualType*>(Begin + getNumArgs()) = AliasedType;
-  }
+  if (IsAlias)
+    *reinterpret_cast<QualType *>(const_cast<TemplateArgument *>(
+        getConvertedArguments().end())) = Underlying;
+
+ArrayRef<TemplateArgument>
+TemplateSpecializationType::getConvertedArguments() const {
+  return {getSpecifiedArguments().end(),
+          TemplateSpecializationTypeBits.NumConvertedArgs};
 }
 
-void
-TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
-                                    TemplateName T,
-                                    ArrayRef<TemplateArgument> Args,
-                                    const ASTContext &Context) {
+QualType TemplateSpecializationType::getAliasedType() const {
+  assert(isTypeAlias() && "not a type alias template specialization");
+  return *reinterpret_cast<const QualType *>(getConvertedArguments().end());
+}
+
+void TemplateSpecializationType::Profile(
+    llvm::FoldingSetNodeID &ID, TemplateName T,
+    ArrayRef<TemplateArgument> SpecifiedArgs,
+    ArrayRef<TemplateArgument> ConvertedArgs, QualType Underlying,
   T.Profile(ID);
-  for (const TemplateArgument &Arg : Args)
+
+  ID.AddInteger(SpecifiedArgs.size());
+  for (const TemplateArgument &Arg : SpecifiedArgs)
     Arg.Profile(ID, Context);
+
+  ID.AddInteger(ConvertedArgs.size());
+  for (const TemplateArgument &Arg : ConvertedArgs)
+    Arg.Profile(ID, Context);
+
+  Underlying.Profile(ID);
 }
 
 QualType
 QualifierCollector::apply(const ASTContext &Context, QualType QT) const {
   if (!hasNonFastQualifiers())
     return QT.withFastQualifiers(getFastQualifiers());
 
   return Context.getQualifiedType(QT, *this);

clang/lib/AST/TypeLoc.cpp

if (getTypePtr()->getQualifier()) {
     setQualifierLoc(Builder.getWithLocInContext(Context));
   } else {
     setQualifierLoc(NestedNameSpecifierLoc());
   }
   setTemplateKeywordLoc(Loc);
   setTemplateNameLoc(Loc);
   setLAngleLoc(Loc);
   setRAngleLoc(Loc);
-  TemplateSpecializationTypeLoc::initializeArgLocs(Context, getNumArgs(),
-                                                   getTypePtr()->getArgs(),
-                                                   getArgInfos(), Loc);
+  TemplateSpecializationTypeLoc::initializeArgLocs(
+      Context,
+      ArrayRef<TemplateArgument>(getTypePtr()->getArgs(), getNumArgs()),
 }
 
-void TemplateSpecializationTypeLoc::initializeArgLocs(ASTContext &Context,
-                                                      unsigned NumArgs,
-                                                  const TemplateArgument *Args,
-                                              TemplateArgumentLocInfo *ArgInfos,
-                                                      SourceLocation Loc) {
-  for (unsigned i = 0, e = NumArgs; i != e; ++i) {
+void TemplateSpecializationTypeLoc::initializeArgLocs(
+    ASTContext &Context, ArrayRef<TemplateArgument> Args,
+    TemplateArgumentLocInfo *ArgInfos, SourceLocation Loc) {
+  for (unsigned i = 0, e = Args.size(); i != e; ++i) {
     switch (Args[i].getKind()) {
     case TemplateArgument::Null:
       llvm_unreachable("Impossible TemplateArgument");
 
     case TemplateArgument::Integral:
     case TemplateArgument::Declaration:
     case TemplateArgument::NullPtr:
       ArgInfos[i] = TemplateArgumentLocInfo();

 void AutoTypeLoc::initializeLocal(ASTContext &Context, SourceLocation Loc) {
   setNestedNameSpecifierLoc(NestedNameSpecifierLoc());
   setTemplateKWLoc(Loc);
   setConceptNameLoc(Loc);
   setFoundDecl(nullptr);
   setRAngleLoc(Loc);
   setLAngleLoc(Loc);
   setRParenLoc(Loc);
-  TemplateSpecializationTypeLoc::initializeArgLocs(Context, getNumArgs(),
-                                                   getTypePtr()->getArgs(),
-                                                   getArgInfos(), Loc);
+  TemplateSpecializationTypeLoc::initializeArgLocs(
+      Context,
+      ArrayRef<TemplateArgument>(getTypePtr()->getArgs(), getNumArgs()),
   setNameLoc(Loc);
 }
 
 
 namespace {
 
   class GetContainedAutoTypeLocVisitor :
     public TypeLocVisitor<GetContainedAutoTypeLocVisitor, TypeLoc> {

clang/lib/AST/TypePrinter.cpp

void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
   // If this is a class template specialization, print the template
   // arguments.
   if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
     ArrayRef<TemplateArgument> Args;
     TypeSourceInfo *TAW = Spec->getTypeAsWritten();
     if (!Policy.PrintCanonicalTypes && TAW) {
       const TemplateSpecializationType *TST =
         cast<TemplateSpecializationType>(TAW->getType());
-      Args = TST->template_arguments();
+      Args = TST->getSpecifiedArguments();
     } else {
       const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
       Args = TemplateArgs.asArray();
     }
     IncludeStrongLifetimeRAII Strong(Policy);
     printTemplateArgumentList(
         OS, Args, Policy,
         Spec->getSpecializedTemplate()->getTemplateParameters());
if (FullyQualify && TD) {
 
     OS << TD->getName();
   } else {
     T->getTemplateName().print(OS, Policy);
   }
 
   DefaultTemplateArgsPolicyRAII TemplateArgs(Policy);
   const TemplateParameterList *TPL = TD ? TD->getTemplateParameters() : nullptr;
-  printTemplateArgumentList(OS, T->template_arguments(), Policy, TPL);
+  ArrayRef<TemplateArgument> Args = T->isCanonicalUnqualified()
+                                        ? T->getConvertedArguments()
+                                        : T->getSpecifiedArguments();
+  printTemplateArgumentList(OS, Args, Policy, TPL);
   spaceBeforePlaceHolder(OS);
 }
 
 void TypePrinter::printTemplateSpecializationBefore(
                                             const TemplateSpecializationType *T,
                                             raw_ostream &OS) {
   printTemplateId(T, OS, Policy.FullyQualifiedName);
 }
static bool isSubstitutedType(ASTContext &Ctx, QualType T, QualType Pattern,
 
   // Recurse into template specialization types.
   if (auto *PTST =
           Pattern.getCanonicalType()->getAs<TemplateSpecializationType>()) {
     TemplateName Template;
     ArrayRef<TemplateArgument> TemplateArgs;
     if (auto *TTST = T->getAs<TemplateSpecializationType>()) {
       Template = TTST->getTemplateName();
-      TemplateArgs = TTST->template_arguments();
+      assert(!TTST->isCanonicalUnqualified());
+      TemplateArgs = TTST->getSpecifiedArguments();
     } else if (auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
                    T->getAsCXXRecordDecl())) {
       Template = TemplateName(CTSD->getSpecializedTemplate());
       TemplateArgs = CTSD->getTemplateArgs().asArray();
     } else {
       return false;
     }
 
     if (!isSubstitutedTemplateArgument(Ctx, Template, PTST->getTemplateName(),
                                        Args, Depth))
       return false;
-    if (TemplateArgs.size() != PTST->getNumArgs())
+    ArrayRef<TemplateArgument> PArgs = PTST->getConvertedArguments();
+    if (TemplateArgs.size() != PArgs.size())
       return false;
     for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
-      if (!isSubstitutedTemplateArgument(Ctx, TemplateArgs[I], PTST->getArg(I),
-                                         Args, Depth))
+      if (!isSubstitutedTemplateArgument(Ctx, TemplateArgs[I], PArgs[I], Args,
+                                         Depth))
         return false;
     return true;
   }
 
   // FIXME: Handle more cases.
   return false;
 }
 

clang/lib/CodeGen/CGDebugInfo.cpp

llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty,
   const auto *AliasDecl = cast<TypeAliasTemplateDecl>(TD)->getTemplatedDecl();
   if (AliasDecl->hasAttr<NoDebugAttr>())
     return Src;
 
   SmallString<128> NS;
   llvm::raw_svector_ostream OS(NS);
   Ty->getTemplateName().print(OS, getPrintingPolicy(),
                               TemplateName::Qualified::None);
-  printTemplateArgumentList(OS, Ty->template_arguments(), getPrintingPolicy());
+  printTemplateArgumentList(OS, Ty->getSpecifiedArguments(),
+                            getPrintingPolicy());
 
   SourceLocation Loc = AliasDecl->getLocation();
   return DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(Loc),
                                 getLineNumber(Loc),
                                 getDeclContextDescriptor(AliasDecl));
 }
 
 /// Convert an AccessSpecifier into the corresponding DINode flag.

clang/lib/Index/USRGeneration.cpp

#include "clang/Basic/RISCVVTypes.def"
     if (const TemplateTypeParmType *TTP = T->getAs<TemplateTypeParmType>()) {
       Out << 't' << TTP->getDepth() << '.' << TTP->getIndex();
       return;
     }
     if (const TemplateSpecializationType *Spec
                                     = T->getAs<TemplateSpecializationType>()) {
       Out << '>';
       VisitTemplateName(Spec->getTemplateName());
-      Out << Spec->getNumArgs();
-      for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
-        VisitTemplateArgument(Spec->getArg(I));
+      Out << Spec->getConvertedArguments().size();
+      for (const TemplateArgument &Arg : Spec->getConvertedArguments())
+        VisitTemplateArgument(Arg);
       return;
     }
     if (const DependentNameType *DNT = T->getAs<DependentNameType>()) {
       Out << '^';
       printQualifier(Out, Ctx, DNT->getQualifier());
       Out << ':' << DNT->getIdentifier()->getName();
       return;
     }

clang/lib/Sema/SemaCXXScopeSpec.cpp

bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
 
   DependentTemplateName *DTN = Template.getAsDependentTemplateName();
   if (DTN && DTN->isIdentifier()) {
     // Handle a dependent template specialization for which we cannot resolve
     // the template name.
     assert(DTN->getQualifier() == SS.getScopeRep());
-    QualType T = Context.getDependentTemplateSpecializationType(ETK_None,
-                                                          DTN->getQualifier(),
-                                                          DTN->getIdentifier(),
-                                                                TemplateArgs);
+    QualType T = Context.getDependentTemplateSpecializationType(
+        ETK_None, DTN->getQualifier(), DTN->getIdentifier(),
+        TemplateArgs.arguments());
 
     // Create source-location information for this type.
     TypeLocBuilder Builder;
     DependentTemplateSpecializationTypeLoc SpecTL
       = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
     SpecTL.setElaboratedKeywordLoc(SourceLocation());
     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
     SpecTL.setTemplateKeywordLoc(TemplateKWLoc);

clang/lib/Sema/SemaCodeComplete.cpp

 /// Try to find a corresponding FunctionProtoType for function-like types (e.g.
 /// function pointers, std::function, etc).
 static const FunctionProtoType *TryDeconstructFunctionLike(QualType T) {
   assert(!T.isNull());
   // Try to extract first template argument from std::function<> and similar.
   // Note we only handle the sugared types, they closely match what users wrote.
   // We explicitly choose to not handle ClassTemplateSpecializationDecl.
   if (auto *Specialization = T->getAs<TemplateSpecializationType>()) {
-    if (Specialization->getNumArgs() != 1)
+    if (Specialization->getSpecifiedArguments().size() != 1)
       return nullptr;
-    const TemplateArgument &Argument = Specialization->getArg(0);
+    const TemplateArgument &Argument =
+        Specialization->getSpecifiedArguments()[0];
     if (Argument.getKind() != TemplateArgument::Type)
       return nullptr;
     return Argument.getAsType()->getAs<FunctionProtoType>();
   }
   // Handle other cases.
   if (T->isPointerType())
     T = T->getPointeeType();
   return T->getAs<FunctionProtoType>();

clang/lib/Sema/SemaDeclCXX.cpp

if (!Specialization)
       return false;
 
     Template = Specialization->getSpecializedTemplate();
     Arguments = Specialization->getTemplateArgs().data();
   } else if (const TemplateSpecializationType *TST =
                  Ty->getAs<TemplateSpecializationType>()) {
     Template = dyn_cast_or_null<ClassTemplateDecl>(
         TST->getTemplateName().getAsTemplateDecl());
-    Arguments = TST->getArgs();
+    Arguments = TST->getSpecifiedArguments().begin();
   }
   if (!Template)
     return false;
 
   if (!StdInitializerList) {
     // Haven't recognized std::initializer_list yet, maybe this is it.
     CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
     if (TemplateClass->getIdentifier() !=

clang/lib/Sema/SemaTemplate.cpp

for (OverloadedTemplateStorage::iterator I = OST->begin(),
         << 0 << (*I)->getDeclName();
 
     return;
   }
 }
 
 static QualType
 checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD,
-                           const SmallVectorImpl<TemplateArgument> &Converted,
+                           ArrayRef<TemplateArgument> SugaredConverted,
+                           ArrayRef<TemplateArgument> CanonicalConverted,
                            SourceLocation TemplateLoc,
                            TemplateArgumentListInfo &TemplateArgs) {
   ASTContext &Context = SemaRef.getASTContext();
 
   TemplateParameterList *TPL = BTD->getTemplateParameters();
 
   // Wrap the type in substitution sugar.
   auto getSubstType = [&](QualType Replacement, unsigned IndexReplaced,
                           Optional<unsigned> PackIndexReplaced) {
     return SemaRef.Context.getSubstTemplateTypeParmType(
         Replacement, BTD, IndexReplaced, PackIndexReplaced);
   };
 
   switch (BTD->getBuiltinTemplateKind()) {
   case BTK__make_integer_seq: {
     // Specializations of __make_integer_seq<S, T, N> are treated like
     // S<T, 0, ..., N-1>.
 
-    QualType OrigType = Converted[1].getAsType();
+    QualType OrigType = SugaredConverted[1].getAsType();
     // C++14 [inteseq.intseq]p1:
     //   T shall be an integer type.
     if (!OrigType->isDependentType() && !OrigType->isIntegralType(Context)) {
       SemaRef.Diag(TemplateArgs[1].getLocation(),
                    diag::err_integer_sequence_integral_element_type);
       return QualType();
     }
 
-    TemplateArgument NumArgsArg = Converted[2];
+    TemplateArgument NumArgsArg = SugaredConverted[2];
     if (NumArgsArg.isDependent())
-      return Context.getCanonicalTemplateSpecializationType(TemplateName(BTD),
-                                                            Converted);
+      return SemaRef.Context.getTemplateSpecializationType(
+          TemplateName(BTD), TemplateArgs.arguments(), SugaredConverted,
+          CanonicalConverted);
 
     TemplateArgumentListInfo SyntheticTemplateArgs;
     // The type argument, wrapped in substitution sugar, gets reused as the
     // first template argument in the synthetic template argument list.
     QualType SyntheticType = getSubstType(OrigType, 1, None);
     SyntheticTemplateArgs.addArgument(
         TemplateArgumentLoc(TemplateArgument(SyntheticType),
                             SemaRef.Context.getTrivialTypeSourceInfo(
if (llvm::APSInt NumArgs = NumArgsArg.getAsIntegral(); NumArgs >= 0) {
       SemaRef.Diag(TemplateArgs[2].getLocation(),
                    diag::err_integer_sequence_negative_length);
       return QualType();
     }
 
     // Wrap the template in substitution sugar.
     TemplateName TN = SemaRef.Context.getSubstTemplateTemplateParm(
         cast<TemplateTemplateParmDecl>(TPL->getParam(0)),
-        Converted[0].getAsTemplate());
+        SugaredConverted[0].getAsTemplate());
 
     // The first template argument will be reused as the template decl that
     // our synthetic template arguments will be applied to.
     return SemaRef.CheckTemplateIdType(TN, TemplateLoc, SyntheticTemplateArgs);
   }
 
   case BTK__type_pack_element:
     // Specializations of
     //    __type_pack_element<Index, T_1, ..., T_N>
     // are treated like T_Index.
-    assert(Converted.size() == 2 &&
+    assert(SugaredConverted.size() == 2 &&
            "__type_pack_element should be given an index and a parameter pack");
 
-    TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
+    TemplateArgument IndexArg = SugaredConverted[0], Ts = SugaredConverted[1];
     if (IndexArg.isDependent() || Ts.isDependent())
-      return Context.getCanonicalTemplateSpecializationType(TemplateName(BTD),
-                                                            Converted);
+      return SemaRef.Context.getTemplateSpecializationType(
+          TemplateName(BTD), TemplateArgs.arguments(), SugaredConverted,
+          CanonicalConverted);
 
     llvm::APSInt Index = IndexArg.getAsIntegral();
     assert(Index >= 0 && "the index used with __type_pack_element should be of "
                          "type std::size_t, and hence be non-negative");
     // If the Index is out of bounds, the program is ill-formed.
     if (Index >= Ts.pack_size()) {
       SemaRef.Diag(TemplateArgs[0].getLocation(),
                    diag::err_type_pack_element_out_of_bounds);
QualType Sema::CheckTemplateIdType(TemplateName Name,
                                    TemplateArgumentListInfo &TemplateArgs) {
   DependentTemplateName *DTN
     = Name.getUnderlying().getAsDependentTemplateName();
   if (DTN && DTN->isIdentifier())
     // When building a template-id where the template-name is dependent,
     // assume the template is a type template. Either our assumption is
     // correct, or the code is ill-formed and will be diagnosed when the
     // dependent name is substituted.
-    return Context.getDependentTemplateSpecializationType(ETK_None,
-                                                          DTN->getQualifier(),
-                                                          DTN->getIdentifier(),
-                                                          TemplateArgs);
+    return Context.getDependentTemplateSpecializationType(
+        ETK_None, DTN->getQualifier(), DTN->getIdentifier(),
+        TemplateArgs.arguments());
 
   if (Name.getAsAssumedTemplateName() &&
       resolveAssumedTemplateNameAsType(/*Scope*/nullptr, Name, TemplateLoc))
     return QualType();
 
-  TemplateDecl *Template = Name.getAsTemplateDecl();
+  TemplateDecl *Template;
+  if (const SubstTemplateTemplateParmPackStorage *S =
+          Name.getAsSubstTemplateTemplateParmPack()) {
+    Template = S->getParameterPack();
+  } else {
+    Template = Name.getAsTemplateDecl();
     if (!Template || isa<FunctionTemplateDecl>(Template) ||
         isa<VarTemplateDecl>(Template) || isa<ConceptDecl>(Template)) {
-    // We might have a substituted template template parameter pack. If so,
-    // build a template specialization type for it.
-    if (Name.getAsSubstTemplateTemplateParmPack())
-      return Context.getTemplateSpecializationType(Name,
-                                                   TemplateArgs.arguments());
-
-    Diag(TemplateLoc, diag::err_template_id_not_a_type)
-      << Name;
+      Diag(TemplateLoc, diag::err_template_id_not_a_type) << Name;
       NoteAllFoundTemplates(Name);
       return QualType();
     }
+  }
 
   // Check that the template argument list is well-formed for this
   // template.
   SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
   if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs, false,
                                 SugaredConverted, CanonicalConverted,
                                 /*UpdateArgsWithConversions=*/true))
     return QualType();
 
   QualType CanonType;
 
-  if (TypeAliasTemplateDecl *AliasTemplate =
+  if (isa<TemplateTemplateParmDecl>(Template)) {
+    // We might have a substituted template template parameter pack. If so,
+    // build a template specialization type for it.
+  } else if (TypeAliasTemplateDecl *AliasTemplate =
                  dyn_cast<TypeAliasTemplateDecl>(Template)) {
 
     // Find the canonical type for this type alias template specialization.
     TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
     if (Pattern->isInvalidDecl())
       return QualType();
 
     // Only substitute for the innermost template argument list.
     MultiLevelTemplateArgumentList TemplateArgLists;
if (CanonType.isNull()) {
           }
         }
       }
 
       return QualType();
     }
   } else if (auto *BTD = dyn_cast<BuiltinTemplateDecl>(Template)) {
     CanonType = checkBuiltinTemplateIdType(*this, BTD, SugaredConverted,
-                                           TemplateLoc, TemplateArgs);
+                                           CanonicalConverted, TemplateLoc,
+                                           TemplateArgs);
   } else if (Name.isDependent() ||
              TemplateSpecializationType::anyDependentTemplateArguments(
                  TemplateArgs, CanonicalConverted)) {
     // This class template specialization is a dependent
     // type. Therefore, its canonical type is another class template
     // specialization type that contains all of the converted
     // arguments in canonical form. This ensures that, e.g., A<T> and
     // A<T, T> have identical types when A is declared as:
     //
     //   template<typename T, typename U = T> struct A;
-    CanonType = Context.getCanonicalTemplateSpecializationType(
-        Name, CanonicalConverted);
+    CanonType = Context.getTemplateSpecializationType(
+        Context.getCanonicalTemplateName(Name), ArrayRef<TemplateArgument>(),
+        None, CanonicalConverted);
 
     // This might work out to be a current instantiation, in which
     // case the canonical type needs to be the InjectedClassNameType.
     //
     // TODO: in theory this could be a simple hashtable lookup; most
     // changes to CurContext don't change the set of current
     // instantiations.
     if (isa<ClassTemplateDecl>(Template)) {
QualType Sema::CheckTemplateIdType(TemplateName Name,
   } else {
     llvm_unreachable("Unhandled template kind");
   }
 
   // Build the fully-sugared type for this class template
   // specialization, which refers back to the class template
   // specialization we created or found.
   return Context.getTemplateSpecializationType(Name, TemplateArgs.arguments(),
-                                               CanonType);
+                                               SugaredConverted,
+                                               CanonicalConverted, CanonType);
 }
 
 void Sema::ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &ParsedName,
                                            TemplateNameKind &TNK,
                                            SourceLocation NameLoc,
                                            IdentifierInfo *&II) {
   assert(TNK == TNK_Undeclared_template && "not an undeclared template name");
 
if (Template.getAsAssumedTemplateName() &&
       resolveAssumedTemplateNameAsType(S, Template, TemplateIILoc))
     return true;
 
   // Translate the parser's template argument list in our AST format.
   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
 
   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
-    QualType T
-      = Context.getDependentTemplateSpecializationType(ETK_None,
-                                                       DTN->getQualifier(),
-                                                       DTN->getIdentifier(),
-                                                       TemplateArgs);
+    assert(SS.getScopeRep() == DTN->getQualifier());
+    QualType T = Context.getDependentTemplateSpecializationType(
+        ETK_None, DTN->getQualifier(), DTN->getIdentifier(),
+        TemplateArgs.arguments());
     // Build type-source information.
     TypeLocBuilder TLB;
     DependentTemplateSpecializationTypeLoc SpecTL
       = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
     SpecTL.setElaboratedKeywordLoc(SourceLocation());
     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
     SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
     SpecTL.setTemplateNameLoc(TemplateIILoc);
TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK,
   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
 
   // Determine the tag kind
   TagTypeKind TagKind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
   ElaboratedTypeKeyword Keyword
     = TypeWithKeyword::getKeywordForTagTypeKind(TagKind);
 
   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
-    QualType T = Context.getDependentTemplateSpecializationType(Keyword,
-                                                          DTN->getQualifier(),
-                                                          DTN->getIdentifier(),
-                                                                TemplateArgs);
+    assert(SS.getScopeRep() == DTN->getQualifier());
+    QualType T = Context.getDependentTemplateSpecializationType(
+        Keyword, DTN->getQualifier(), DTN->getIdentifier(),
+        TemplateArgs.arguments());
 
     // Build type-source information.
     TypeLocBuilder TLB;
     DependentTemplateSpecializationTypeLoc SpecTL
       = TLB.push<DependentTemplateSpecializationTypeLoc>(T);
     SpecTL.setElaboratedKeywordLoc(TagLoc);
     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
     SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
if (TUK != TUK_Friend &&
                                        isPartialSpecialization))
     return true;
 
   // The canonical type
   QualType CanonType;
   if (isPartialSpecialization) {
     // Build the canonical type that describes the converted template
     // arguments of the class template partial specialization.
-    TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
-    CanonType = Context.getTemplateSpecializationType(CanonTemplate,
-                                                      CanonicalConverted);
+    CanonType = Context.getTemplateSpecializationType(
+        Context.getCanonicalTemplateName(Name), ArrayRef<TemplateArgument>(),
+        None, CanonicalConverted);
 
     if (Context.hasSameType(CanonType,
                         ClassTemplate->getInjectedClassNameSpecialization()) &&
         (!Context.getLangOpts().CPlusPlus20 ||
          !TemplateParams->hasAssociatedConstraints())) {
       // C++ [temp.class.spec]p9b3:
       //
       //   -- The argument list of the specialization shall not be identical
if (TemplateParameterLists.size() > 0) {
       Specialization->setTemplateParameterListsInfo(Context,
                                                     TemplateParameterLists);
     }
 
     if (!PrevDecl)
       ClassTemplate->AddSpecialization(Specialization, InsertPos);
 
     if (CurContext->isDependentContext()) {
-      TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
-      CanonType = Context.getTemplateSpecializationType(CanonTemplate,
-                                                        CanonicalConverted);
+      CanonType = Context.getTemplateSpecializationType(
+          Context.getCanonicalTemplateName(Name), ArrayRef<TemplateArgument>(),
+          None, CanonicalConverted);
     } else {
       CanonType = Context.getTypeDeclType(Specialization);
     }
   }
 
   // C++ [temp.expl.spec]p6:
   //   If a template, a member template or the member of a class template is
   //   explicitly specialized then that specialization shall be declared
DeclResult Sema::ActOnClassTemplateSpecialization(
 
   // Build the fully-sugared type for this class template
   // specialization as the user wrote in the specialization
   // itself. This means that we'll pretty-print the type retrieved
   // from the specialization's declaration the way that the user
   // actually wrote the specialization, rather than formatting the
   // name based on the "canonical" representation used to store the
   // template arguments in the specialization.
-  TypeSourceInfo *WrittenTy
-    = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
-                                                TemplateArgs, CanonType);
+  TypeSourceInfo *WrittenTy = Context.getTemplateSpecializationTypeInfo(
+      Name, TemplateNameLoc, TemplateArgs, SugaredConverted, CanonicalConverted,
+      CanonType);
   if (TUK != TUK_Friend) {
     Specialization->setTypeAsWritten(WrittenTy);
     Specialization->setTemplateKeywordLoc(TemplateKWLoc);
   }
 
   // C++ [temp.expl.spec]p9:
   //   A template explicit specialization is in the scope of the
   //   namespace in which the template was defined.
DeclResult Sema::ActOnExplicitInstantiation(
 
   // Build the fully-sugared type for this explicit instantiation as
   // the user wrote in the explicit instantiation itself. This means
   // that we'll pretty-print the type retrieved from the
   // specialization's declaration the way that the user actually wrote
   // the explicit instantiation, rather than formatting the name based
   // on the "canonical" representation used to store the template
   // arguments in the specialization.
-  TypeSourceInfo *WrittenTy
-    = Context.getTemplateSpecializationTypeInfo(Name, TemplateNameLoc,
-                                                TemplateArgs,
-                                  Context.getTypeDeclType(Specialization));
+  TypeSourceInfo *WrittenTy = Context.getTemplateSpecializationTypeInfo(
+      Name, TemplateNameLoc, TemplateArgs, SugaredConverted, CanonicalConverted,
   Specialization->setTypeAsWritten(WrittenTy);
 
   // Set source locations for keywords.
   Specialization->setExternLoc(ExternLoc);
   Specialization->setTemplateKeywordLoc(TemplateLoc);
   Specialization->setBraceRange(SourceRange());
 
   bool PreviouslyDLLExported = Specialization->hasAttr<DLLExportAttr>();
Sema::ActOnTypenameType(Scope *S,
   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
 
   TemplateName Template = TemplateIn.get();
   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
     // Construct a dependent template specialization type.
     assert(DTN && "dependent template has non-dependent name?");
     assert(DTN->getQualifier() == SS.getScopeRep());
-    QualType T = Context.getDependentTemplateSpecializationType(ETK_Typename,
-                                                          DTN->getQualifier(),
-                                                          DTN->getIdentifier(),
-                                                                TemplateArgs);
+    QualType T = Context.getDependentTemplateSpecializationType(
+        ETK_Typename, DTN->getQualifier(), DTN->getIdentifier(),
+        TemplateArgs.arguments());
 
     // Create source-location information for this type.
     TypeLocBuilder Builder;
     DependentTemplateSpecializationTypeLoc SpecTL
     = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
     SpecTL.setElaboratedKeywordLoc(TypenameLoc);
     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
     SpecTL.setTemplateKeywordLoc(TemplateKWLoc);

clang/lib/Sema/SemaTemplateDeduction.cpp

 static Sema::TemplateDeductionResult
 DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
                             const QualType P, QualType A,
                             TemplateDeductionInfo &Info,
                             SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
   QualType UP = P;
   if (const auto *IP = P->getAs<InjectedClassNameType>())
     UP = IP->getInjectedSpecializationType();
-  // FIXME: Try to preserve type sugar here, which is hard
-  // because of the unresolved template arguments.
-  const auto *TP = UP.getCanonicalType()->castAs<TemplateSpecializationType>();
+  assert(isa<TemplateSpecializationType>(UP.getCanonicalType()));
+  const TemplateSpecializationType *TP =
+      UP->castAsNonAliasTemplateSpecializationType();
   TemplateName TNP = TP->getTemplateName();
 
   // If the parameter is an alias template, there is nothing to deduce.
   if (const auto *TD = TNP.getAsTemplateDecl(); TD && TD->isTypeAlias())
     return Sema::TDK_Success;
 
-  ArrayRef<TemplateArgument> PResolved = TP->template_arguments();
+  ArrayRef<TemplateArgument> PResolved = TP->getConvertedArguments();
 
   QualType UA = A;
   // Treat an injected-class-name as its underlying template-id.
   if (const auto *Injected = A->getAs<InjectedClassNameType>())
     UA = Injected->getInjectedSpecializationType();
 
   // Check whether the template argument is a dependent template-id.
-  // FIXME: Should not lose sugar here.
-  if (const auto *SA =
-          dyn_cast<TemplateSpecializationType>(UA.getCanonicalType())) {
+  if (const auto *SA = UA->getAsNonAliasTemplateSpecializationType()) {
     TemplateName TNA = SA->getTemplateName();
 
     // If the argument is an alias template, there is nothing to deduce.
     if (const auto *TD = TNA.getAsTemplateDecl(); TD && TD->isTypeAlias())
       return Sema::TDK_Success;
 
     // Perform template argument deduction for the template name.
     if (auto Result =
             DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info, Deduced))
       return Result;
     // Perform template argument deduction on each template
     // argument. Ignore any missing/extra arguments, since they could be
     // filled in by default arguments.
     return DeduceTemplateArguments(S, TemplateParams, PResolved,
-                                   SA->template_arguments(), Info, Deduced,
+                                   SA->getConvertedArguments(), Info, Deduced,
                                    /*NumberOfArgumentsMustMatch=*/false);
   }
 
   // If the argument type is a class template specialization, we
   // perform template argument deduction using its template
   // arguments.
   const auto *RA = UA->getAs<RecordType>();
   const auto *SA =
FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
   if (!ClangABICompat15) {
     for (int i = 0, e = std::min(NumParams1, NumParams2); i < e; ++i) {
       QualType T1 = FD1->getParamDecl(i)->getType().getCanonicalType();
       QualType T2 = FD2->getParamDecl(i)->getType().getCanonicalType();
       auto *TST1 = dyn_cast<TemplateSpecializationType>(T1);
       auto *TST2 = dyn_cast<TemplateSpecializationType>(T2);
       if (!TST1 || !TST2)
         continue;
-      const TemplateArgument &TA1 = TST1->template_arguments().back();
+      const TemplateArgument &TA1 = TST1->getConvertedArguments().back();
       if (TA1.getKind() == TemplateArgument::Pack) {
-        assert(TST1->getNumArgs() == TST2->getNumArgs());
-        const TemplateArgument &TA2 = TST2->template_arguments().back();
+        assert(TST1->getConvertedArguments().size() ==
+               TST2->getConvertedArguments().size());
+        const TemplateArgument &TA2 = TST2->getConvertedArguments().back();
         assert(TA2.getKind() == TemplateArgument::Pack);
         unsigned PackSize1 = TA1.pack_size();
         unsigned PackSize2 = TA2.pack_size();
         bool IsPackExpansion1 =
             PackSize1 && TA1.pack_elements().back().isPackExpansion();
         bool IsPackExpansion2 =
             PackSize2 && TA2.pack_elements().back().isPackExpansion();
         if (PackSize1 != PackSize2 && IsPackExpansion1 != IsPackExpansion2) {
if (Inst.isInvalid())
     return false;
 
   auto *TST1 = T1->castAs<TemplateSpecializationType>();
   bool AtLeastAsSpecialized;
   S.runWithSufficientStackSpace(Info.getLocation(), [&] {
     AtLeastAsSpecialized = !FinishTemplateArgumentDeduction(
         S, P2, /*IsPartialOrdering=*/true,
         TemplateArgumentList(TemplateArgumentList::OnStack,
-                             TST1->template_arguments()),
+                             TST1->getConvertedArguments()),
         Deduced, Info);
   });
   return AtLeastAsSpecialized;
 }
 
 namespace {
 // A dummy pass to return nullptr instead of P2 when performing "more
 // specialized than primary" check.
getMoreSpecialized(Sema &S, QualType T1, QualType T2, TemplateLikeDecl *P1,
   if (Better1 && Better2) {
     // This a speculative fix for CWG1432 (Similar to the fix for CWG1395) that
     // there is no wording or even resolution for this issue.
     bool ClangABICompat15 = S.Context.getLangOpts().getClangABICompat() <=
                             LangOptions::ClangABI::Ver15;
     if (!ClangABICompat15) {
       auto *TST1 = cast<TemplateSpecializationType>(T1);
       auto *TST2 = cast<TemplateSpecializationType>(T2);
-      const TemplateArgument &TA1 = TST1->template_arguments().back();
+      const TemplateArgument &TA1 = TST1->getConvertedArguments().back();
       if (TA1.getKind() == TemplateArgument::Pack) {
-        assert(TST1->getNumArgs() == TST2->getNumArgs());
-        const TemplateArgument &TA2 = TST2->template_arguments().back();
+        assert(TST1->getConvertedArguments().size() ==
+               TST2->getConvertedArguments().size());
+        const TemplateArgument &TA2 = TST2->getConvertedArguments().back();
         assert(TA2.getKind() == TemplateArgument::Pack);
         unsigned PackSize1 = TA1.pack_size();
         unsigned PackSize2 = TA2.pack_size();
         bool IsPackExpansion1 =
             PackSize1 && TA1.pack_elements().back().isPackExpansion();
         bool IsPackExpansion2 =
             PackSize2 && TA2.pack_elements().back().isPackExpansion();
         if (PackSize1 != PackSize2 && IsPackExpansion1 != IsPackExpansion2) {
Sema::getMoreSpecializedPartialSpecialization(
   // Pretend the variable template specializations are class template
   // specializations and form a fake injected class name type for comparison.
   assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() &&
          "the partial specializations being compared should specialize"
          " the same template.");
   TemplateName Name(PS1->getSpecializedTemplate());
   TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
   QualType PT1 = Context.getTemplateSpecializationType(
-      CanonTemplate, PS1->getTemplateArgs().asArray());
+      CanonTemplate, ArrayRef<TemplateArgument>(), None,
+      PS1->getTemplateArgs().asArray());
   QualType PT2 = Context.getTemplateSpecializationType(
-      CanonTemplate, PS2->getTemplateArgs().asArray());
+      CanonTemplate, ArrayRef<TemplateArgument>(), None,
+      PS2->getTemplateArgs().asArray());
 
   TemplateDeductionInfo Info(Loc);
   return getMoreSpecialized(*this, PT1, PT2, PS1, PS2, Info);
 }
 
 bool Sema::isMoreSpecializedThanPrimary(
     VarTemplatePartialSpecializationDecl *Spec, TemplateDeductionInfo &Info) {
   TemplateDecl *Primary = Spec->getSpecializedTemplate();
   // FIXME: Cache the injected template arguments rather than recomputing
   // them for each partial specialization.
   SmallVector<TemplateArgument, 8> PrimaryArgs;
   Context.getInjectedTemplateArgs(Primary->getTemplateParameters(),
                                   PrimaryArgs);
+  Context.getCanonicalTemplateArguments(PrimaryArgs, PrimaryArgs);
+
+  SmallVector<TemplateArgument, 8> SpecArgs;
+  Context.getCanonicalTemplateArguments(Spec->getTemplateArgs().asArray(),
+                                        SpecArgs);
 
   TemplateName CanonTemplate =
       Context.getCanonicalTemplateName(TemplateName(Primary));
   QualType PrimaryT = Context.getTemplateSpecializationType(
-      CanonTemplate, PrimaryArgs);
+      CanonTemplate, ArrayRef<TemplateArgument>(), None, PrimaryArgs);
   QualType PartialT = Context.getTemplateSpecializationType(
-      CanonTemplate, Spec->getTemplateArgs().asArray());
+      CanonTemplate, ArrayRef<TemplateArgument>(), None, SpecArgs);
 
   VarTemplatePartialSpecializationDecl *MaybeSpec =
       getMoreSpecialized(*this, PartialT, PrimaryT, Spec, Primary, Info);
   if (MaybeSpec)
     Info.clearSFINAEDiagnostic();
   return MaybeSpec;
 }
 
bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
   TemplateName X = Context.getCanonicalTemplateName(TemplateName(AArg));
   TemplateParameterList *A = AArg->getTemplateParameters();
 
   //    - Each function template has a single function parameter whose type is
   //      a specialization of X with template arguments corresponding to the
   //      template parameters from the respective function template
   SmallVector<TemplateArgument, 8> AArgs;
   Context.getInjectedTemplateArgs(A, AArgs);
+  Context.getCanonicalTemplateArguments(AArgs, AArgs);
 
   // Check P's arguments against A's parameter list. This will fill in default
   // template arguments as needed. AArgs are already correct by construction.
   // We can't just use CheckTemplateIdType because that will expand alias
   // templates.
   SmallVector<TemplateArgument, 4> PArgs;
   {
     SFINAETrap Trap(*this);
 
     Context.getInjectedTemplateArgs(P, PArgs);
+    Context.getCanonicalTemplateArguments(PArgs, PArgs);
     TemplateArgumentListInfo PArgList(P->getLAngleLoc(),
                                       P->getRAngleLoc());
     for (unsigned I = 0, N = P->size(); I != N; ++I) {
       // Unwrap packs that getInjectedTemplateArgs wrapped around pack
       // expansions, to form an "as written" argument list.
       TemplateArgument Arg = PArgs[I];
       if (Arg.getKind() == TemplateArgument::Pack) {
         assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion());
SmallVector<TemplateArgument, 4> PArgs;
     //   specialized as A.
     SmallVector<TemplateArgument, 4> SugaredPArgs;
     if (CheckTemplateArgumentList(AArg, Loc, PArgList, false, SugaredPArgs,
                                   PArgs) ||
         Trap.hasErrorOccurred())
       return false;
   }
 
-  QualType AType = Context.getCanonicalTemplateSpecializationType(X, AArgs);
-  QualType PType = Context.getCanonicalTemplateSpecializationType(X, PArgs);
+  QualType AType = Context.getTemplateSpecializationType(
+      X, ArrayRef<TemplateArgument>(), None, AArgs);
+  QualType PType = Context.getTemplateSpecializationType(
+      X, ArrayRef<TemplateArgument>(), None, PArgs);
 
   //   ... the function template corresponding to P is at least as specialized
   //   as the function template corresponding to A according to the partial
   //   ordering rules for function templates.
   TemplateDeductionInfo Info(Loc, A->getDepth());
   return isAtLeastAsSpecializedAs(*this, PType, AType, AArg, Info);
 }
 
const TemplateSpecializationType *Spec
       = cast<TemplateSpecializationType>(T);
     MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced,
                                Depth, Used);
 
     // C++0x [temp.deduct.type]p9:
     //   If the template argument list of P contains a pack expansion that is
     //   not the last template argument, the entire template argument list is a
     //   non-deduced context.
-    if (OnlyDeduced &&
-        hasPackExpansionBeforeEnd(Spec->template_arguments()))
+    if (OnlyDeduced && hasPackExpansionBeforeEnd(Spec->getConvertedArguments()))
       break;
 
-    for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
-      MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
-                                 Used);
+    for (const TemplateArgument &Arg : Spec->getConvertedArguments())
+      MarkUsedTemplateParameters(Ctx, Arg, OnlyDeduced, Depth, Used);
     break;
   }
 
   case Type::Complex:
     if (!OnlyDeduced)
       MarkUsedTemplateParameters(Ctx,
                                  cast<ComplexType>(T)->getElementType(),
                                  OnlyDeduced, Depth, Used);

clang/lib/Sema/SemaTemplateInstantiate.cpp

assert(
         "Outer template not instantiated?");
     if (ClassTemplate->isMemberSpecialization())
       return Response::Done();
     if (ForConstraintInstantiation) {
       QualType RecordType = Context.getTypeDeclType(Rec);
       QualType Injected = cast<InjectedClassNameType>(RecordType)
                               ->getInjectedSpecializationType();
       const auto *InjectedType = cast<TemplateSpecializationType>(Injected);
-      Result.addOuterTemplateArguments(Rec, InjectedType->template_arguments());
+      Result.addOuterTemplateArguments(Rec,
+                                       InjectedType->getConvertedArguments());
     }
   }
 
   bool IsFriend = Rec->getFriendObjectKind() ||
                   (Rec->getDescribedClassTemplate() &&
                    Rec->getDescribedClassTemplate()->getFriendObjectKind());
   if (ForConstraintInstantiation && IsFriend &&
       Rec->getNonTransparentDeclContext()->isFileContext()) {

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
   // specializations.
   if (!PrevDecl)
     InstClassTemplate->AddSpecialization(InstD, InsertPos);
 
   // Substitute the nested name specifier, if any.
   if (SubstQualifier(D, InstD))
     return nullptr;
 
-  // Build the canonical type that describes the converted template
-  // arguments of the class template explicit specialization.
-  QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
-      TemplateName(InstClassTemplate), CanonicalConverted,
-      SemaRef.Context.getRecordType(InstD));
-
   // Build the fully-sugared type for this class template
   // specialization as the user wrote in the specialization
   // itself. This means that we'll pretty-print the type retrieved
   // from the specialization's declaration the way that the user
   // actually wrote the specialization, rather than formatting the
   // name based on the "canonical" representation used to store the
   // template arguments in the specialization.
   TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
       TemplateName(InstClassTemplate), D->getLocation(), InstTemplateArgs,
-      CanonType);
+      SugaredConverted, CanonicalConverted,
+      SemaRef.Context.getRecordType(InstD));
 
   InstD->setAccess(D->getAccess());
   InstD->setInstantiationOfMemberClass(D, TSK_ImplicitInstantiation);
   InstD->setSpecializationKind(D->getSpecializationKind());
   InstD->setTypeAsWritten(WrittenTy);
   InstD->setExternLoc(D->getExternLoc());
   InstD->setTemplateKeywordLoc(D->getTemplateKeywordLoc());
 
TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
 
   // Figure out where to insert this class template partial specialization
   // in the member template's set of class template partial specializations.
   void *InsertPos = nullptr;
   ClassTemplateSpecializationDecl *PrevDecl =
       ClassTemplate->findPartialSpecialization(CanonicalConverted, InstParams,
                                                InsertPos);
 
-  // Build the canonical type that describes the converted template
-  // arguments of the class template partial specialization.
-  QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
-      TemplateName(ClassTemplate), CanonicalConverted);
-
   // Build the fully-sugared type for this class template
   // specialization as the user wrote in the specialization
   // itself. This means that we'll pretty-print the type retrieved
   // from the specialization's declaration the way that the user
   // actually wrote the specialization, rather than formatting the
   // name based on the "canonical" representation used to store the
   // template arguments in the specialization.
-  TypeSourceInfo *WrittenTy
-    = SemaRef.Context.getTemplateSpecializationTypeInfo(
-                                                    TemplateName(ClassTemplate),
-                                                    PartialSpec->getLocation(),
-                                                    InstTemplateArgs,
-                                                    CanonType);
+  TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
+      TemplateName(ClassTemplate), PartialSpec->getLocation(), InstTemplateArgs,
+      SugaredConverted, CanonicalConverted);
 
   if (PrevDecl) {
     // We've already seen a partial specialization with the same template
     // parameters and template arguments. This can happen, for example, when
     // substituting the outer template arguments ends up causing two
     // class template partial specializations of a member class template
     // to have identical forms, e.g.,
     //
TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
   }
 
 
   // Create the class template partial specialization declaration.
   ClassTemplatePartialSpecializationDecl *InstPartialSpec =
       ClassTemplatePartialSpecializationDecl::Create(
           SemaRef.Context, PartialSpec->getTagKind(), Owner,
           PartialSpec->getBeginLoc(), PartialSpec->getLocation(), InstParams,
-          ClassTemplate, CanonicalConverted, InstTemplateArgs, CanonType,
-          nullptr);
+          ClassTemplate, CanonicalConverted, InstTemplateArgs,
+          WrittenTy->getType(), nullptr);
   // Substitute the nested name specifier, if any.
   if (SubstQualifier(PartialSpec, InstPartialSpec))
     return nullptr;
 
   InstPartialSpec->setInstantiatedFromMember(PartialSpec);
   InstPartialSpec->setTypeAsWritten(WrittenTy);
 
   // Check the completed partial specialization.
TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
 
   // Figure out where to insert this variable template partial specialization
   // in the member template's set of variable template partial specializations.
   void *InsertPos = nullptr;
   VarTemplateSpecializationDecl *PrevDecl =
       VarTemplate->findPartialSpecialization(CanonicalConverted, InstParams,
                                              InsertPos);
 
-  // Build the canonical type that describes the converted template
-  // arguments of the variable template partial specialization.
-  QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
-      TemplateName(VarTemplate), CanonicalConverted);
-
   // Build the fully-sugared type for this variable template
   // specialization as the user wrote in the specialization
   // itself. This means that we'll pretty-print the type retrieved
   // from the specialization's declaration the way that the user
   // actually wrote the specialization, rather than formatting the
   // name based on the "canonical" representation used to store the
   // template arguments in the specialization.
   TypeSourceInfo *WrittenTy = SemaRef.Context.getTemplateSpecializationTypeInfo(
       TemplateName(VarTemplate), PartialSpec->getLocation(), InstTemplateArgs,
-      CanonType);
+      SugaredConverted, CanonicalConverted);
 
   if (PrevDecl) {
     // We've already seen a partial specialization with the same template
     // parameters and template arguments. This can happen, for example, when
     // substituting the outer template arguments ends up causing two
     // variable template partial specializations of a member variable template
     // to have identical forms, e.g.,
     //

clang/lib/Sema/TreeTransform.h

TemplateName InstName = getDerived().RebuildTemplateName(
         SS, TemplateKWLoc, *Name, NameLoc, QualType(), nullptr,
         AllowInjectedClassName);
 
     if (InstName.isNull())
       return QualType();
 
     // If it's still dependent, make a dependent specialization.
     if (InstName.getAsDependentTemplateName())
-      return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
-                                          QualifierLoc.getNestedNameSpecifier(),
-                                                                    Name,
-                                                                    Args);
+      return SemaRef.Context.getDependentTemplateSpecializationType(
+          Keyword, QualifierLoc.getNestedNameSpecifier(), Name,
+          Args.arguments());
 
     // Otherwise, make an elaborated type wrapping a non-dependent
     // specialization.
     QualType T =
         getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
     if (T.isNull())
       return QualType();
     return SemaRef.Context.getElaboratedType(

 template <typename Derived>
 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
                                                         TypeLocBuilder &TLB,
                                            TemplateSpecializationTypeLoc TL,
                                                       TemplateName Template) {
   TemplateArgumentListInfo NewTemplateArgs;
   NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
   NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
-  typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
-    ArgIterator;
-  if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
-                                              ArgIterator(TL, TL.getNumArgs()),
-                                              NewTemplateArgs))
+
+  const auto *T = cast<TemplateSpecializationType>(TL.getType());
+  if (T->isCanonicalUnqualified()) {
+    ArrayRef<TemplateArgument> ConvertedArgs = T->getConvertedArguments();
+    using ArgIterator =
+        TemplateArgumentLocInventIterator<Derived, const TemplateArgument *>;
+    if (getDerived().TransformTemplateArguments(
+            ArgIterator(*this, ConvertedArgs.begin()),
+            ArgIterator(*this, ConvertedArgs.end()), NewTemplateArgs))
+      return QualType();
+  } else {
+    using ArgIterator =
+        TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>;
+    if (getDerived().TransformTemplateArguments(
+            ArgIterator(TL, 0), ArgIterator(TL, TL.getNumArgs()),
       return QualType();
+  }
 
   // FIXME: maybe don't rebuild if all the template arguments are the same.
 
   QualType Result =
     getDerived().RebuildTemplateSpecializationType(Template,
                                                    TL.getTemplateNameLoc(),
                                                    NewTemplateArgs);
 
QualType TreeTransform<Derived>::TransformDependentTemplateSpecializationType(
   if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                               ArgIterator(TL, TL.getNumArgs()),
                                               NewTemplateArgs))
     return QualType();
 
   // FIXME: maybe don't rebuild if all the template arguments are the same.
 
   if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) {
-    QualType Result
-      = getSema().Context.getDependentTemplateSpecializationType(
-                                                TL.getTypePtr()->getKeyword(),
-                                                         DTN->getQualifier(),
-                                                         DTN->getIdentifier(),
-                                                               NewTemplateArgs);
+    QualType Result = getSema().Context.getDependentTemplateSpecializationType(
+        TL.getTypePtr()->getKeyword(), DTN->getQualifier(),
+        DTN->getIdentifier(), NewTemplateArgs.arguments());
 
     DependentTemplateSpecializationTypeLoc NewTL
       = TLB.push<DependentTemplateSpecializationTypeLoc>(Result);
     NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
     NewTL.setQualifierLoc(SS.getWithLocInContext(SemaRef.Context));
     NewTL.setTemplateKeywordLoc(TL.getTemplateKeywordLoc());
     NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
     NewTL.setLAngleLoc(TL.getLAngleLoc());

clang/lib/Serialization/ASTReader.cpp

 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
                                            TemplateSpecializationTypeLoc TL) {
   TL.setTemplateKeywordLoc(readSourceLocation());
   TL.setTemplateNameLoc(readSourceLocation());
   TL.setLAngleLoc(readSourceLocation());
   TL.setRAngleLoc(readSourceLocation());
   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
     TL.setArgLocInfo(
-        i,
-        Reader.readTemplateArgumentLocInfo(
-          TL.getTypePtr()->getArg(i).getKind()));
+        i, Reader.readTemplateArgumentLocInfo(
+               TL.getTypePtr()->getSpecifiedArguments()[i].getKind()));
 }
 
 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
   TL.setLParenLoc(readSourceLocation());
   TL.setRParenLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {

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

 template<class T> template<class T2> struct A<T>::C::B<T2*> { }; 
 
 A<short>::C::B<int*> absip;
 
 // Check for conflicts during template instantiation. 
 template<typename T, typename U>
 struct Outer {
   template<typename X, typename Y> struct Inner;
-  template<typename Y> struct Inner<T, Y> {}; // expected-note{{previous declaration of class template partial specialization 'Inner<int, type-parameter-0-0>' is here}}
+  template<typename Y> struct Inner<T, Y> {}; // expected-note{{previous declaration of class template partial specialization 'Inner<int, Y>' is here}}
   template<typename Y> struct Inner<U, Y> {}; // expected-error{{cannot be redeclared}}
 };
 
 Outer<int, int> outer; // expected-note{{instantiation}}
 
 // Test specialization of class template partial specialization members.
 template<> template<typename Z>
 struct X0<float>::Inner0<Z*> {
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<0, int, type-parameter-0-0>' is here}}
+  // expected-note-re@-1 {{previous declaration {{.*}} 'Bar<0, int, Y>' 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

clang/test/SemaTemplate/deduction.cpp

namespace cwg_example {
     template<typename T, typename ...U> void j(void(*)(U...), void (*...fns)(T, U));
     void test() { j(x, f, x); }
   }
 }
 
 namespace b29946541 {
   template<typename> class A {};
   template<typename T, typename U, template<typename, typename> class C>
-  void f(C<T, U>); // expected-note {{failed template argument deduction}}
+  void f(C<T, U>); // expected-note {{couldn't infer template argument 'U'}}
   void g(A<int> a) { f(a); } // expected-error {{no match}}
 }
 
 namespace deduction_from_empty_list {
   template<int M, int N = 5> void f(int (&&)[N], int (&&)[N]) { // expected-note {{1 vs. 2}}
     static_assert(M == N, "");
   }
 

clang/test/SemaTemplate/make_integer_seq.cpp

 // CHECK-NEXT:       |   |-value: Int 1
 // CHECK-NEXT:       |   `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:42> 'int' 1
 // CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} 'A<int, 0>' sugar A
 // CHECK-NEXT:         |-TemplateArgument type 'int':'int'
 // CHECK-NEXT:         | `-SubstTemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'int' sugar typename depth 0 index 1
 // CHECK-NEXT:         |   |-BuiltinTemplate 0x{{[0-9A-Fa-f]+}} '__make_integer_seq'
 // CHECK-NEXT:         |   `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
 // CHECK-NEXT:         |-TemplateArgument expr
-// CHECK-NEXT:         | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'int'
+// CHECK-NEXT:         | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'int':'int'
 // CHECK-NEXT:         |   |-value: Int 0
 // CHECK-NEXT:         |   `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:42> 'int':'int' 0
 // CHECK-NEXT:         `-RecordType 0x{{[0-9A-Fa-f]+}} 'A<int, 0>'
 // CHECK-NEXT:           `-ClassTemplateSpecialization 0x{{[0-9A-Fa-f]+}} 'A'
 
 template <class B1, B1 B2> using B = __make_integer_seq<A, B1, B2>;
 using test2 = B<int, 1>;
 //      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:29:1, col:23> col:7 test2 'B<int, 1>':'A<int, 0>'

 // CHECK-NEXT:             | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:64> 'int'
 // CHECK-NEXT:             |   |-value: Int 0
 // CHECK-NEXT:             |   `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:64> 'int':'int' 0
 // CHECK-NEXT:             `-RecordType 0x{{[0-9A-Fa-f]+}} 'A<int, 0>'
 // CHECK-NEXT:               `-ClassTemplateSpecialization 0x{{[0-9A-Fa-f]+}} 'A'
 
 template <template <class T, T...> class S, class T, int N> struct C {
   using test3 = __make_integer_seq<S, T, N>;
-//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:67:3, col:43> col:9 test3 '__make_integer_seq<S, T, N>':'__make_integer_seq<type-parameter-0-1, N>'
+//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:67:3, col:43> col:9 test3 '__make_integer_seq<S, T, N>':'__make_integer_seq<S, T, N>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<S, T, N>' sugar dependent
 // CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<S, T, N>' sugar dependent alias __make_integer_seq
 // CHECK-NEXT:       |-TemplateArgument template S
 // CHECK-NEXT:       |-TemplateArgument type 'T'
 // CHECK-NEXT:       | `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'T' dependent depth 0 index 1
 // CHECK-NEXT:       |   `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'T'
 // CHECK-NEXT:       |-TemplateArgument expr
 // CHECK-NEXT:       | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'T':'T' <Dependent>
 // CHECK-NEXT:       |   `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
-// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<type-parameter-0-1, N>' dependent __make_integer_seq
-// CHECK-NEXT:         |-TemplateArgument template
-// CHECK-NEXT:         |-TemplateArgument type 'type-parameter-0-1'
-// CHECK-NEXT:         | `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'type-parameter-0-1' dependent depth 0 index 1
+// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<S, T, N>' dependent __make_integer_seq
+// CHECK-NEXT:         |-TemplateArgument template S
+// CHECK-NEXT:         |-TemplateArgument type 'T'
+// CHECK-NEXT:         | `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'T' dependent depth 0 index 1
+// CHECK-NEXT:         |   `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'T'
 // CHECK-NEXT:         `-TemplateArgument expr
 // CHECK-NEXT:           `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'T':'T' <Dependent>
 // CHECK-NEXT:             `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
 
   using test4 = __make_integer_seq<A, T, 1>;
-//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:86:3, col:43> col:9 test4 '__make_integer_seq<A, T, 1>':'__make_integer_seq<A, type-parameter-0-1, 1>'
+//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:87:3, col:43> col:9 test4 '__make_integer_seq<A, T, 1>':'__make_integer_seq<A, T, 1>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, T, 1>' sugar dependent
 // CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, T, 1>' sugar dependent alias __make_integer_seq
 // CHECK-NEXT:       |-TemplateArgument template A
 // CHECK-NEXT:       |-TemplateArgument type 'T'
 // CHECK-NEXT:       | `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'T' dependent depth 0 index 1
 // CHECK-NEXT:       |   `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'T'
 // CHECK-NEXT:       |-TemplateArgument expr
 // CHECK-NEXT:       | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'T':'T' <Dependent>
 // CHECK-NEXT:       |   `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:42> 'int' 1
-// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, type-parameter-0-1, 1>' dependent __make_integer_seq
+// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, T, 1>' dependent __make_integer_seq
 // CHECK-NEXT:         |-TemplateArgument template A
-// CHECK-NEXT:         |-TemplateArgument type 'type-parameter-0-1'
-// CHECK-NEXT:         | `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'type-parameter-0-1' dependent depth 0 index 1
+// CHECK-NEXT:         |-TemplateArgument type 'T'
+// CHECK-NEXT:         | `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'T' dependent depth 0 index 1
+// CHECK-NEXT:         |   `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'T'
 // CHECK-NEXT:         `-TemplateArgument expr
 // CHECK-NEXT:           `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:42> 'T':'T' <Dependent>
 // CHECK-NEXT:             `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:42> 'int' 1
 
   using test5 = __make_integer_seq<A, int, N>;
-//      CHECK: `-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:105:3, col:45> col:9 test5 '__make_integer_seq<A, int, N>':'__make_integer_seq<A, int, N>'
+//      CHECK: `-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:107:3, col:45> col:9 test5 '__make_integer_seq<A, int, N>':'__make_integer_seq<A, int, N>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, N>' sugar dependent
 // CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, N>' sugar dependent alias __make_integer_seq
 // CHECK-NEXT:       |-TemplateArgument template A
 // CHECK-NEXT:       |-TemplateArgument type 'int'
 // CHECK-NEXT:       | `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
 // CHECK-NEXT:       |-TemplateArgument expr
 // CHECK-NEXT:       | `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:44> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
 // CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, N>' dependent __make_integer_seq

clang/test/SemaTemplate/type_pack_element.cpp

 // CHECK-NEXT:       |-TemplateArgument type 'int'
 // CHECK-NEXT:       | `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
 // CHECK-NEXT:       `-SubstTemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'int' sugar typename depth 0 index 1 ... pack_index 0
 // CHECK-NEXT:         |-BuiltinTemplate 0x{{[0-9A-Fa-f]+}} '__type_pack_element'
 // CHECK-NEXT:         `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
 
 template<int N, class ...Ts> struct A {
   using test2 = __type_pack_element<N, Ts...>;
-//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:19:3, col:45> col:9 test2 '__type_pack_element<N, Ts...>':'__type_pack_element<N, type-parameter-0-1...>'
+//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:19:3, col:45> col:9 test2 '__type_pack_element<N, Ts...>':'__type_pack_element<N, Ts...>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, Ts...>' sugar dependent
 // CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, Ts...>' sugar dependent alias __type_pack_element
 // CHECK-NEXT:       |-TemplateArgument expr
 // CHECK-NEXT:       | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
 // CHECK-NEXT:       |   `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
 // CHECK-NEXT:       |-TemplateArgument type 'Ts...'
 // CHECK-NEXT:       | `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'Ts...' dependent
 // CHECK-NEXT:       |   `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'Ts' dependent contains_unexpanded_pack depth 0 index 1 pack
 // CHECK-NEXT:       |     `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'Ts'
-// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, type-parameter-0-1...>' dependent __type_pack_element
+// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, Ts...>' dependent __type_pack_element
 // CHECK-NEXT:         |-TemplateArgument expr
 // CHECK-NEXT:         | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
 // CHECK-NEXT:         |   `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
-// CHECK-NEXT:         `-TemplateArgument pack
-// CHECK-NEXT:           `-TemplateArgument type 'type-parameter-0-1...'
-// CHECK-NEXT:             `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'type-parameter-0-1...' dependent
-// CHECK-NEXT:               `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'type-parameter-0-1' dependent contains_unexpanded_pack depth 0 index 1 pack
+// CHECK-NEXT:         `-TemplateArgument type 'Ts...'
+// CHECK-NEXT:           `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'Ts...' dependent
+// CHECK-NEXT:             `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'Ts' dependent contains_unexpanded_pack depth 0 index 1 pack
+// CHECk-NEXT:               `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'Ts'
 
   using test3 = __type_pack_element<0, Ts...>;
-//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:39:3, col:45> col:9 test3 '__type_pack_element<0, Ts...>':'__type_pack_element<0, type-parameter-0-1...>'
+//      CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:39:3, col:45> col:9 test3 '__type_pack_element<0, Ts...>':'__type_pack_element<0, Ts...>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, Ts...>' sugar dependent
 // CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, Ts...>' sugar dependent alias __type_pack_element
 // CHECK-NEXT:       |-TemplateArgument expr
 // CHECK-NEXT:       | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long'
 // CHECK-NEXT:       |   |-value: Int 0
 // CHECK-NEXT:       |   `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
 // CHECK-NEXT:       |     `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:37> 'int' 0
 // CHECK-NEXT:       |-TemplateArgument type 'Ts...'
 // CHECK-NEXT:       | `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'Ts...' dependent
 // CHECK-NEXT:       |   `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'Ts' dependent contains_unexpanded_pack depth 0 index 1 pack
 // CHECK-NEXT:       |     `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'Ts'
-// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, type-parameter-0-1...>' dependent __type_pack_element
-// CHECK-NEXT:         |-TemplateArgument integral 0
-// CHECK-NEXT:         `-TemplateArgument pack
-// CHECK-NEXT:           `-TemplateArgument type 'type-parameter-0-1...'
-// CHECK-NEXT:             `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'type-parameter-0-1...' dependent
-// CHECK-NEXT:               `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'type-parameter-0-1' dependent contains_unexpanded_pack depth 0 index 1 pack
+// CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, Ts...>' dependent __type_pack_element
+// CHECK-NEXT:         |-TemplateArgument expr
+// CHECK-NEXT:         | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long'
+// CHECK-NEXT:         |   |-value: Int 0
+// CHECK-NEXT:         |   `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
+// CHECK-NEXT:         |     `-IntegerLiteral 0x{{[0-9A-Fa-f]+}} <col:37> 'int' 0
+// CHECK-NEXT:         `-TemplateArgument type 'Ts...'
+// CHECK-NEXT:           `-PackExpansionType 0x{{[0-9A-Fa-f]+}} 'Ts...' dependent
+// CHECK-NEXT:             `-TemplateTypeParmType 0x{{[0-9A-Fa-f]+}} 'Ts' dependent contains_unexpanded_pack depth 0 index 1 pack
+// CHECK-NEXT:               `-TemplateTypeParm 0x{{[0-9A-Fa-f]+}} 'Ts'
 
   using test4 = __type_pack_element<N, int>;
-//      CHECK: `-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:59:3, col:43> col:9 test4 '__type_pack_element<N, int>':'__type_pack_element<N, int>'
+//      CHECK: `-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:63:3, col:43> col:9 test4 '__type_pack_element<N, int>':'__type_pack_element<N, int>'
 // CHECK-NEXT:   `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, int>' sugar dependent
 // CHECK-NEXT:     `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, int>' sugar dependent alias __type_pack_element
 // CHECK-NEXT:       |-TemplateArgument expr
 // CHECK-NEXT:       | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
 // CHECK-NEXT:       |   `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
 // CHECK-NEXT:       |-TemplateArgument type 'int'
 // CHECK-NEXT:       | `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
 // CHECK-NEXT:       `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<N, int>' dependent __type_pack_element
 // CHECK-NEXT:         |-TemplateArgument expr
 // CHECK-NEXT:         | `-ImplicitCastExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'unsigned long' <IntegralCast>
 // CHECK-NEXT:         |   `-DeclRefExpr 0x{{[0-9A-Fa-f]+}} <col:37> 'int' NonTypeTemplateParm 0x{{[0-9A-Fa-f]+}} 'N' 'int'
-// CHECK-NEXT:         `-TemplateArgument pack
-// CHECK-NEXT:           `-TemplateArgument type 'int'
-// CHECK-NEXT:             `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
+// CHECK-NEXT:         `-TemplateArgument type 'int'
+// CHECK-NEXT:           `-BuiltinType 0x{{[0-9A-Fa-f]+}} 'int'
 };
 
 // expected-no-diagnostics
 
 template <class T, class S> struct B;
 template <class T> struct B<T, __type_pack_element<sizeof(T), void, long>> {};
 template struct B<char, long>;
 

clang/tools/libclang/CXType.cpp

 static inline CXTranslationUnit GetTU(CXType CT) {
   return static_cast<CXTranslationUnit>(CT.data[1]);
 }
 
 static Optional<ArrayRef<TemplateArgument>>
 GetTemplateArguments(QualType Type) {
   assert(!Type.isNull());
   if (const auto *Specialization = Type->getAs<TemplateSpecializationType>())
-    return Specialization->template_arguments();
+    return Specialization->getSpecifiedArguments();
 
   if (const auto *RecordDecl = Type->getAsCXXRecordDecl()) {
     const auto *TemplateDecl =
       dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl);
     if (TemplateDecl)
       return TemplateDecl->getTemplateArgs().asArray();
   }