[Clang][Sema] Use correct TemplateName when transforming TemplateSpecializationType

Author: jcsxky

clang/lib/Sema/TreeTransform.h

@@ -29,10 +29,8 @@
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/StmtOpenACC.h"
 #include "clang/AST/StmtOpenMP.h"
-#include "clang/AST/TypeLoc.h"
 #include "clang/Basic/DiagnosticParse.h"
 #include "clang/Basic/OpenMPKinds.h"
-#include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Designator.h"
 #include "clang/Sema/EnterExpressionEvaluationContext.h"
 #include "clang/Sema/Lookup.h"
@@ -7219,48 +7217,30 @@ TreeTransform<Derived>::TransformElaboratedType(TypeLocBuilder &TLB,
   }
 
   QualType NamedT;
-  if (0 && SemaRef.getLangOpts().CPlusPlus20 && QualifierLoc && isa<TemplateSpecializationType>(TL.getNamedTypeLoc().getType())) {
-    const TemplateSpecializationType *TST = TL.getNamedTypeLoc().getType()->getAs<TemplateSpecializationType>();
+  if (SemaRef.getLangOpts().CPlusPlus20 && QualifierLoc &&
+      isa<TemplateSpecializationType>(TL.getNamedTypeLoc().getType())) {
     TemplateSpecializationTypeLoc SpecTL =
         TL.getNamedTypeLoc().castAs<TemplateSpecializationTypeLoc>();
-    // TemplateArgumentListInfo NewTemplateArgs;
-    // NewTemplateArgs.setLAngleLoc(SpecTL.getLAngleLoc());
-    // NewTemplateArgs.setRAngleLoc(SpecTL.getRAngleLoc());
-
-    // typedef TemplateArgumentLocContainerIterator<
-    // TemplateSpecializationTypeLoc> ArgIterator;
-    // if (getDerived().TransformTemplateArguments(ArgIterator(SpecTL, 0),
-    //                                             ArgIterator(SpecTL, SpecTL.getNumArgs()),
-    //                                             NewTemplateArgs))
-    //   return QualType();
-
+    const TemplateSpecializationType *TST =
+        SpecTL.getType()->castAs<TemplateSpecializationType>();
     CXXScopeSpec SS;
     SS.Adopt(QualifierLoc);
-    TemplateName InstName = getDerived().RebuildTemplateName(
-        SS, TL.getTemplateKeywordLoc(), *TST->getTemplateName().getAsTemplateDecl()->getIdentifier(), TL.getNamedTypeLoc().getBeginLoc(), QualType(), nullptr,
-        false);
-
-    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.arguments());
-
-    // Otherwise, make an elaborated type wrapping a non-dependent
-    // specialization.
-    // NamedT = getDerived().RebuildTemplateSpecializationType(InstName, TL.getNamedTypeLoc().getBeginLoc(), NewTemplateArgs);
-    NamedT = TransformTemplateSpecializationType(TLB, SpecTL, InstName);
-  } else {
+    if (TemplateDecl *TD = TST->getTemplateName().getAsTemplateDecl()) {
+      TemplateName InstName = getDerived().RebuildTemplateName(
+          SS, TL.getTemplateKeywordLoc(), *TD->getIdentifier(),
+          TL.getNamedTypeLoc().getBeginLoc(), /*ObjectType=*/QualType(),
+          /*FirstQualifierInScope=*/nullptr, /*AllowInjectedClassName=*/false);
+      if (InstName.isNull())
+        return QualType();
+      NamedT = TransformTemplateSpecializationType(TLB, SpecTL, InstName);
+    }
+  }
+  if (NamedT.isNull()) {
     NamedT = getDerived().TransformType(TLB, TL.getNamedTypeLoc());
-    
+    if (NamedT.isNull())
+      return QualType();
   }
 
-  if (NamedT.isNull())
-    return QualType();
-
   // C++0x [dcl.type.elab]p2:
   //   If the identifier resolves to a typedef-name or the simple-template-id
   //   resolves to an alias template specialization, the

clang/test/SemaCXX/PR91677.cpp

@@ -0,0 +1,31 @@
+// RUN: %clang_cc1 -verify -std=c++20 -fsyntax-only %s
+// expected-no-diagnostics
+
+template <typename> struct t1 {
+  template <typename>
+  struct t2 {};
+};
+
+template <typename T>
+t1<T>::template t2<T> f1();
+
+void f2() {
+  f1<bool>();
+}
+
+namespace N {
+  template <typename T> struct A {
+    struct B {
+      template <typename U> struct X {};
+      typedef int arg;
+    };
+    struct C {
+      typedef B::template X<B::arg> x;
+    };
+  };
+
+  template <> struct A<int>::B {
+    template <int N> struct X {};
+    static const int arg = 0;
+  };
+}

clang/test/SemaTemplate/typename-specifier-3.cpp

@@ -28,16 +28,17 @@ namespace PR12884_original {
       typedef int arg;
     };
     struct C {
-      typedef B::X<typename B::arg> x; // precxx17-warning{{missing 'typename' prior to dependent type name B::X; implicit 'typename' is a C++20 extension}}
+      typedef B::X<typename B::arg> x; // precxx17-warning{{missing 'typename' prior to dependent type name B::X; implicit 'typename' is a C++20 extension}} \
+                                       cxx17-error{{typename specifier refers to non-type member 'arg' in 'PR12884_original::A<int>::B'}}
     };
   };
 
   template <> struct A<int>::B {
     template <int N> struct X {};
-    static const int arg = 0;
+    static const int arg = 0; // cxx17-note{{referenced member 'arg' is declared here}}
   };
 
-  A<int>::C::x a;
+  A<int>::C::x a; // cxx17-note{{in instantiation of member class 'PR12884_original::A<int>::C' requested here}}
 }
 namespace PR12884_half_fixed {
   template <typename T> struct A {