[clang] Fix a UsingTemplate regression after 3e78fa860235431323aaf08c8fa922d75a7cfffa

[hokein]

Summary

TemplateName::getAsTemplateDecl() returns the underlying TemplateDecl
for a UsingTemplate kind template name. We should respect that in the
Profile method otherwise we might desugar the template name unexpectedly
(e.g. for template argument deduction with deduciton guides).

[kadircet]

FWIW, I believe this patch does the right thing by marking the DeducedTemplateSpecializationType as using. It's explicitly introduced into the global namespace through the using decl, and even before 3e78fa860235431323aaf08c8fa922d75a7cfffa we weren't marking them as such.

But I am still not sure about the implications of this in the modules world. So adding @ChuanqiXu as a reviewer in case he has more insights.

[ChuanqiXu]

Yeah, this one should be correct. Modules techniques use *::Profile method to judge if two entities are the same extensively. So it would be best to add a test case for modules like we did in https://reviews.llvm.org/rG3e78fa860235431323aaf08c8fa922d75a7cfffa. And it doesn't matter if you are not interested, I'll take it later then.

[hokein]

Thanks for the review.

In D146202#4198904, @ChuanqiXu wrote:

Yeah, this one should be correct. Modules techniques use *::Profile method to judge if two entities are the same extensively. So it would be best to add a test case for modules like we did in https://reviews.llvm.org/rG3e78fa860235431323aaf08c8fa922d75a7cfffa. And it doesn't matter if you are not interested, I'll take it later then.

I'm landing the patch as-is now. It would be nice for you to add a related test for modules afterwards (since I don't have much knowledge about clang module stuff).

clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

TEST(WalkAST, TemplateNames) {
   testWalk(R"cpp(
       template <typename> struct S {};
       template <typename T> $explicit^using foo = S<T>;)cpp",
            "^foo<int> x;");
   testWalk(R"cpp(
       namespace ns {template <typename> struct S {}; }
       using ns::$explicit^S;)cpp",
            "^S<int> x;");
+  testWalk(R"cpp(
+      namespace ns {
+        template <typename T> struct S { S(T);};
+        template <typename T> S(T t) -> S<T>;
+      }
+      using ns::$explicit^S;)cpp",
+      "^S x(123);");
   testWalk("template<typename> struct $explicit^S {};",
            R"cpp(
       template <template <typename> typename> struct X {};
       X<^S> x;)cpp");
   testWalk("template<typename T> struct $explicit^S { S(T); };", "^S s(42);");
   // Should we mark the specialization instead?
   testWalk(
       "template<typename> struct $explicit^S {}; template <> struct S<int> {};",

clang/lib/AST/TemplateName.cpp

bool TemplateName::isInstantiationDependent() const {
   return getDependence() & TemplateNameDependence::Instantiation;
 }
 
 bool TemplateName::containsUnexpandedParameterPack() const {
   return getDependence() & TemplateNameDependence::UnexpandedPack;
 }
 
 void TemplateName::Profile(llvm::FoldingSetNodeID &ID) {
-  if (auto *TD = getAsTemplateDecl())
+  if (const auto* USD = getAsUsingShadowDecl())
+    ID.AddPointer(USD->getCanonicalDecl());
+  else if (const auto *TD = getAsTemplateDecl())
     ID.AddPointer(TD->getCanonicalDecl());
   else
     ID.AddPointer(Storage.getOpaqueValue());
 }
 
 void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
                          Qualified Qual) const {
   auto Kind = getKind();

clang/test/AST/ast-dump-using-template.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c++17 -ast-dump %s | FileCheck -strict-whitespace %s
 
 // Tests to verify we construct correct using template names.
 // TemplateNames are not dumped, so the sugar here isn't obvious. However
 // the "using" on the TemplateSpecializationTypes shows that the
 // UsingTemplateName is present.
 namespace ns {
 template<typename T> class S {
  public:
    S(T);
 };
+template<typename T> struct S2 { S2(T); };
+template <typename T> S2(T t) -> S2<T>;
 }
 using ns::S;
+using ns::S2;
 
 // TemplateName in TemplateSpecializationType.
 template<typename T>
 using A = S<T>;
 // CHECK:      TypeAliasDecl
 // CHECK-NEXT: `-ElaboratedType {{.*}} 'S<T>' sugar dependent
 // CHECK-NEXT:   `-TemplateSpecializationType {{.*}} 'S<T>' dependent using S
 

 
 // TemplateName in DeducedTemplateSpecializationType.
 S DeducedTemplateSpecializationT(123);
 using C = decltype(DeducedTemplateSpecializationT);
 // CHECK:      DecltypeType {{.*}}
 // CHECK-NEXT:  |-DeclRefExpr {{.*}}
 // CHECK-NEXT:  `-ElaboratedType {{.*}} 'S<int>' sugar
 // CHECK-NEXT:    `-DeducedTemplateSpecializationType {{.*}} 'ns::S<int>' sugar using
+
+S2 DeducedTemplateSpecializationT2(123);
+using D = decltype(DeducedTemplateSpecializationT2);
+// CHECK:      DecltypeType {{.*}}
+// CHECK-NEXT:  |-DeclRefExpr {{.*}}
+// CHECK-NEXT:  `-ElaboratedType {{.*}} 'S2<int>' sugar
+// CHECK-NEXT:    `-DeducedTemplateSpecializationType {{.*}} 'S2<int>' sugar using