WIP

Author: mizvekov

clang/include/clang/AST/ASTContext.h

@@ -1840,10 +1840,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
   QualType getDependentTemplateSpecializationType(
       ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
       ArrayRef<TemplateArgumentLoc> Args) const;
-  QualType
-  getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
-                                         const DependentTemplateStorage &Name,
-                                         ArrayRef<TemplateArgument> Args) const;
+  QualType getDependentTemplateSpecializationType(
+      ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
+      ArrayRef<TemplateArgument> Args, bool IsCanonical = false) const;
 
   TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl) const;
 

clang/lib/AST/ASTContext.cpp

@@ -5774,44 +5774,53 @@ QualType ASTContext::getDependentTemplateSpecializationType(
 
 QualType ASTContext::getDependentTemplateSpecializationType(
     ElaboratedTypeKeyword Keyword, const DependentTemplateStorage &Name,
-    ArrayRef<TemplateArgument> Args) const {
+    ArrayRef<TemplateArgument> Args, bool IsCanonical) const {
   llvm::FoldingSetNodeID ID;
   DependentTemplateSpecializationType::Profile(ID, *this, Keyword, Name, Args);
 
   void *InsertPos = nullptr;
-  DependentTemplateSpecializationType *T
-    = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
-  if (T)
+  if (auto *T = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(
+          ID, InsertPos))
     return QualType(T, 0);
 
-  NestedNameSpecifier *NNS = Name.getQualifier(),
-                      *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
-
-  ElaboratedTypeKeyword CanonKeyword = Keyword;
-  if (Keyword == ElaboratedTypeKeyword::None)
-    CanonKeyword = ElaboratedTypeKeyword::Typename;
-
-  bool AnyNonCanonArgs = false;
-  auto CanonArgs =
-      ::getCanonicalTemplateArguments(*this, Args, AnyNonCanonArgs);
+  NestedNameSpecifier *NNS = Name.getQualifier();
 
   QualType Canon;
-  if (AnyNonCanonArgs || CanonNNS != NNS || !Name.hasTemplateKeyword() ||
-      CanonKeyword != Keyword) {
-    Canon = getDependentTemplateSpecializationType(
-        CanonKeyword, {CanonNNS, Name.getName(), /*HasTemplateKeyword=*/true},
-        CanonArgs);
-
-    // Find the insert position again.
-    [[maybe_unused]] auto *Nothing =
-        DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!Nothing && "canonical type broken");
+  if (!IsCanonical) {
+    ElaboratedTypeKeyword CanonKeyword = Keyword != ElaboratedTypeKeyword::None
+                                             ? Keyword
+                                             : ElaboratedTypeKeyword::Typename;
+    NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
+    bool AnyNonCanonArgs = false;
+    auto CanonArgs =
+        ::getCanonicalTemplateArguments(*this, Args, AnyNonCanonArgs);
+
+    if (AnyNonCanonArgs || CanonNNS != NNS || !Name.hasTemplateKeyword() ||
+        CanonKeyword != Keyword) {
+      Canon = getDependentTemplateSpecializationType(
+          CanonKeyword, {CanonNNS, Name.getName(), /*HasTemplateKeyword=*/true},
+          CanonArgs, /*IsCanonical=*/true);
+      // Find the insert position again.
+      [[maybe_unused]] auto *Nothing =
+          DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID,
+                                                                   InsertPos);
+      assert(!Nothing && "canonical type broken");
+    }
+  } else {
+    assert(Keyword != ElaboratedTypeKeyword::None);
+    assert(Name.hasTemplateKeyword());
+    assert(NNS == getCanonicalNestedNameSpecifier(NNS));
+#ifndef NDEBUG
+    bool AnyNonCanonArgs = false;
+    ::getCanonicalTemplateArguments(*this, Args, AnyNonCanonArgs);
+    assert(!AnyNonCanonArgs);
+#endif
   }
-
   void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
                         sizeof(TemplateArgument) * Args.size()),
                        alignof(DependentTemplateSpecializationType));
-  T = new (Mem) DependentTemplateSpecializationType(Keyword, Name, Args, Canon);
+  auto *T =
+      new (Mem) DependentTemplateSpecializationType(Keyword, Name, Args, Canon);
   Types.push_back(T);
   DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
   return QualType(T, 0);
@@ -7625,7 +7634,7 @@ ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const {
       QualType NewT = getDependentTemplateSpecializationType(
           ElaboratedTypeKeyword::Typename,
           {/*NNS=*/nullptr, DTN.getName(), /*HasTemplateKeyword=*/true},
-          DTST->template_arguments());
+          DTST->template_arguments(), /*IsCanonical=*/true);
       assert(NewT.isCanonical());
       NestedNameSpecifier *Prefix = DTN.getQualifier();
       if (!Prefix)

clang/lib/AST/ItaniumMangle.cpp

@@ -2187,7 +2187,7 @@ void CXXNameMangler::manglePrefix(NestedNameSpecifier *qualifier) {
           DTST->getKeyword(),
           {Prefix, DTST->getDependentTemplateName().getName(),
            /*HasTemplateKeyword=*/true},
-          DTST->template_arguments());
+          DTST->template_arguments(), /*IsCanonical=*/true);
       manglePrefix(NewT);
       return;
     }