WIP: [clang] store sugared converted arguments on TemplateSpecializationType

Not ready for review

This is a quite large patch, half of which will
be redone following a different approach.

Although it improves sugar retention in template argument
deduction on its own, this is an enabler for resugaring.

This stores the sugared converted template arguments in
a TST, in addition to the existing as-written ones,
so this is quite wasteful.

This is the biggest performance impact on the whole
of resugaring so far, although it is hoped the
new approach will have negligible impact.

This is a continuation of https://reviews.llvm.org/D134113

Author: mizvekov

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

@@ -94,9 +94,9 @@ void UseTransparentFunctorsCheck::check(
   unsigned ArgNum = 0;
   const auto *FunctorParentType =
       FunctorParentLoc.getType()->castAs<TemplateSpecializationType>();
-  for (; ArgNum < FunctorParentType->template_arguments().size(); ++ArgNum) {
+  for (; ArgNum < FunctorParentType->getSpecifiedArguments().size(); ++ArgNum) {
     const TemplateArgument &Arg =
-        FunctorParentType->template_arguments()[ArgNum];
+        FunctorParentType->getSpecifiedArguments()[ArgNum];
     if (Arg.getKind() != TemplateArgument::Type)
       continue;
     QualType ParentArgType = Arg.getAsType();
@@ -106,7 +106,7 @@ void UseTransparentFunctorsCheck::check(
       break;
   }
   // Functor is a default template argument.
-  if (ArgNum == FunctorParentType->template_arguments().size())
+  if (ArgNum == FunctorParentType->getSpecifiedArguments().size())
     return;
   TemplateArgumentLoc FunctorLoc = FunctorParentLoc.getArgLoc(ArgNum);
   auto FunctorTypeLoc = getInnerTypeLocAs<TemplateSpecializationTypeLoc>(

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

@@ -181,7 +181,7 @@ isCXXComplexTypeMatching(const TemplateSpecializationType *const Template,
   if (Template->getAsCXXRecordDecl()->getName() != "complex")
     return true;
 
-  const auto *Builtin = Template->template_arguments()[0]
+  const auto *Builtin = Template->getSpecifiedArguments()[0]
                             .getAsType()
                             .getTypePtr()
                             ->getAs<BuiltinType>();

clang-tools-extra/clangd/AST.cpp

@@ -438,9 +438,15 @@ bool hasReservedScope(const DeclContext &DC) {
 QualType declaredType(const TypeDecl *D) {
   ASTContext &Context = D->getASTContext();
   if (const auto *CTSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(D))
-    if (const auto *Args = CTSD->getTemplateArgsAsWritten())
+    if (const auto *ArgList = CTSD->getTemplateArgsAsWritten()) {
+      SmallVector<TemplateArgument, 4> Args(ArgList->arguments().size());
+      for (unsigned I = 0, E = Args.size(); I < E; ++I)
+        Args[I] = ArgList->arguments()[I].getArgument();
       return Context.getTemplateSpecializationType(
-          TemplateName(CTSD->getSpecializedTemplate()), Args->arguments());
+          TemplateName(CTSD->getSpecializedTemplate()), Args,
+          /*SugaredConvertedArgs=*/std::nullopt,
+          /*CanonicalConvertedArgs=*/std::nullopt);
+    }
   return Context.getTypeDeclType(D);
 }
 

clang/include/clang/AST/ASTContext.h

@@ -1810,22 +1810,24 @@ class ASTContext : public RefCountedBase<ASTContext> {
                           bool ParameterPack,
                           TemplateTypeParmDecl *ParmDecl = nullptr) const;
 
-  QualType getTemplateSpecializationType(TemplateName T,
-                                         ArrayRef<TemplateArgument> Args,
-                                         QualType Canon = QualType()) const;
-
-  QualType
-  getCanonicalTemplateSpecializationType(TemplateName T,
-                                         ArrayRef<TemplateArgument> Args) const;
-
-  QualType getTemplateSpecializationType(TemplateName T,
-                                         ArrayRef<TemplateArgumentLoc> Args,
-                                         QualType Canon = QualType()) const;
-
-  TypeSourceInfo *
-  getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc,
-                                    const TemplateArgumentListInfo &Args,
-                                    QualType Canon = QualType()) const;
+  QualType getTemplateSpecializationType(
+      TemplateName T, ArrayRef<TemplateArgument> SpecifiedArgs,
+      ArrayRef<TemplateArgument> SugaredConvertedArgs,
+      ArrayRef<TemplateArgument> CanonicalConvertedArgs,
+      QualType Canon = QualType()) const;
+
+  QualType getTemplateSpecializationType(
+      TemplateName T, ArrayRef<TemplateArgumentLoc> SpecifiedArgs,
+      ArrayRef<TemplateArgument> SugaredConvertedArgs,
+      ArrayRef<TemplateArgument> CanonicalConvertedArgs,
+      QualType Canon = QualType()) const;
+
+  TypeSourceInfo *getTemplateSpecializationTypeInfo(
+      TemplateName T, SourceLocation TLoc,
+      const TemplateArgumentListInfo &SpecifiedArgs,
+      ArrayRef<TemplateArgument> SugaredConvertedArgs,
+      ArrayRef<TemplateArgument> CanonicalConvertedArgs,
+      QualType Canon = QualType()) const;
 
   QualType getParenType(QualType NamedType) const;
 
@@ -1845,7 +1847,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
       const IdentifierInfo *Name, ArrayRef<TemplateArgumentLoc> Args) const;
   QualType getDependentTemplateSpecializationType(
       ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
-      const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args) const;
+      const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args,
+      bool Canonical = false) const;
 
   TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl) const;
 
@@ -2936,6 +2939,12 @@ class ASTContext : public RefCountedBase<ASTContext> {
   TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg)
     const;
 
+  /// Canonicalize the given template argument list.
+  ///
+  /// Returns true if any arguments were non-canonical, false otherwise.
+  bool
+  canonicalizeTemplateArguments(MutableArrayRef<TemplateArgument> Args) 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

clang/include/clang/AST/ASTNodeTraverser.h

@@ -452,7 +452,7 @@ class ASTNodeTraverser
     Visit(T->getArgumentPack());
   }
   void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
-    for (const auto &Arg : T->template_arguments())
+    for (const auto &Arg : T->getSpecifiedArguments())
       Visit(Arg);
   }
   void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {

clang/include/clang/AST/DeclTemplate.h

@@ -608,8 +608,10 @@ class FunctionTemplateSpecializationInfo final
   Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
           const ASTContext &Context) {
     ID.AddInteger(TemplateArgs.size());
+    // We allow instantiating deduction guides with non-canonical template
+    // arguments.
     for (const TemplateArgument &TemplateArg : TemplateArgs)
-      TemplateArg.Profile(ID, Context);
+      TemplateArg.Profile(ID, Context, /*Canonical=*/false);
   }
 };
 
@@ -2096,7 +2098,7 @@ class ClassTemplateSpecializationDecl : public CXXRecordDecl,
           const ASTContext &Context) {
     ID.AddInteger(TemplateArgs.size());
     for (const TemplateArgument &TemplateArg : TemplateArgs)
-      TemplateArg.Profile(ID, Context);
+      TemplateArg.Profile(ID, Context, /*Canonical=*/true);
   }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
@@ -2869,7 +2871,7 @@ class VarTemplateSpecializationDecl : public VarDecl,
                       const ASTContext &Context) {
     ID.AddInteger(TemplateArgs.size());
     for (const TemplateArgument &TemplateArg : TemplateArgs)
-      TemplateArg.Profile(ID, Context);
+      TemplateArg.Profile(ID, Context, /*Canonical=*/true);
   }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -1134,7 +1134,10 @@ DEF_TRAVERSE_TYPE(SubstTemplateTypeParmPackType, {
 
 DEF_TRAVERSE_TYPE(TemplateSpecializationType, {
   TRY_TO(TraverseTemplateName(T->getTemplateName()));
-  TRY_TO(TraverseTemplateArguments(T->template_arguments()));
+  if (T->isCanonicalUnqualified())
+    TRY_TO(TraverseTemplateArguments(T->getConvertedArguments()));
+  else
+    TRY_TO(TraverseTemplateArguments(T->getSpecifiedArguments()));
 })
 
 DEF_TRAVERSE_TYPE(InjectedClassNameType, {})

clang/include/clang/AST/TemplateBase.h

@@ -465,7 +465,8 @@ class TemplateArgument {
   void dump() const;
 
   /// Used to insert TemplateArguments into FoldingSets.
-  void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const;
+  void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
+               bool Canonical) const;
 };
 
 /// Location information for a TemplateArgument.

clang/include/clang/AST/Type.h

@@ -2208,10 +2208,9 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
     /// 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 {
@@ -2830,6 +2829,18 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
   /// 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
@@ -6601,7 +6612,7 @@ class AutoType : public DeducedType {
   static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                       QualType Deduced, AutoTypeKeyword Keyword,
                       bool IsDependent, ConceptDecl *CD,
-                      ArrayRef<TemplateArgument> Arguments);
+                      ArrayRef<TemplateArgument> Arguments, bool Canonical);
 
   static bool classof(const Type *T) {
     return T->getTypeClass() == Auto;
@@ -6679,10 +6690,10 @@ class TemplateSpecializationType : public Type, public llvm::FoldingSetNode {
   /// 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.
@@ -6735,11 +6746,13 @@ class TemplateSpecializationType : public Type, public llvm::FoldingSetNode {
   /// Retrieve the name of the template that we are specializing.
   TemplateName getTemplateName() const { return Template; }
 
-  ArrayRef<TemplateArgument> template_arguments() const {
+  ArrayRef<TemplateArgument> getSpecifiedArguments() const {
     return {reinterpret_cast<const TemplateArgument *>(this + 1),
-            TemplateSpecializationTypeBits.NumArgs};
+            TemplateSpecializationTypeBits.NumSpecifiedArgs};
   }
 
+  ArrayRef<TemplateArgument> getConvertedArguments() const;
+
   bool isSugared() const {
     return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
   }
@@ -6750,8 +6763,10 @@ class TemplateSpecializationType : public Type, public llvm::FoldingSetNode {
 
   void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &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,
+                      bool Canonical);
 
   static bool classof(const Type *T) {
     return T->getTypeClass() == TemplateSpecialization;
@@ -7110,15 +7125,15 @@ class DependentTemplateSpecializationType : public TypeWithKeyword,
   QualType desugar() const { return QualType(this, 0); }
 
   void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
-    Profile(ID, Context, getKeyword(), NNS, Name, template_arguments());
+    Profile(ID, Context, getKeyword(), NNS, Name, template_arguments(),
+            isCanonicalUnqualified());
   }
 
-  static void Profile(llvm::FoldingSetNodeID &ID,
-                      const ASTContext &Context,
+  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                       ElaboratedTypeKeyword Keyword,
                       NestedNameSpecifier *Qualifier,
                       const IdentifierInfo *Name,
-                      ArrayRef<TemplateArgument> Args);
+                      ArrayRef<TemplateArgument> Args, bool Canonical);
 
   static bool classof(const Type *T) {
     return T->getTypeClass() == DependentTemplateSpecialization;

clang/include/clang/AST/TypeLoc.h

@@ -1718,7 +1718,7 @@ class TemplateSpecializationTypeLoc :
   }
 
   unsigned getNumArgs() const {
-    return getTypePtr()->template_arguments().size();
+    return getTypePtr()->getSpecifiedArguments().size();
   }
 
   void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI) {
@@ -1730,7 +1730,7 @@ class TemplateSpecializationTypeLoc :
   }
 
   TemplateArgumentLoc getArgLoc(unsigned i) const {
-    return TemplateArgumentLoc(getTypePtr()->template_arguments()[i],
+    return TemplateArgumentLoc(getTypePtr()->getSpecifiedArguments()[i],
                                getArgLocInfo(i));
   }
 
@@ -1766,7 +1766,7 @@ class TemplateSpecializationTypeLoc :
     setTemplateNameLoc(Loc);
     setLAngleLoc(Loc);
     setRAngleLoc(Loc);
-    initializeArgLocs(Context, getTypePtr()->template_arguments(),
+    initializeArgLocs(Context, getTypePtr()->getSpecifiedArguments(),
                       getArgInfos(), Loc);
   }