Add a unsupported testcase.

The implementations doesn't support the using-alias-chain usage at the moment.

Tweak the implementation not crashing, and add a testcase for this

Author: hokein

clang/lib/Sema/SemaInit.cpp

@@ -11008,17 +11008,25 @@ QualType Sema::DeduceTemplateSpecializationFromInitializer(
   if (!Template) {
     if (AliasTemplate = dyn_cast_or_null<TypeAliasTemplateDecl>(
              TemplateName.getAsTemplateDecl()); AliasTemplate) {
-      llvm::errs() << "alias template decl\n";
-      auto UnderlyingType = AliasTemplate->getTemplatedDecl()
+      // Unrap the sugar ElaboratedType.
+      auto RhsType = AliasTemplate->getTemplatedDecl()
                                 ->getUnderlyingType()
-                                .getDesugaredType(Context);
+                                .getSingleStepDesugaredType(Context);
       if (const auto *TST =
-              UnderlyingType->getAs<TemplateSpecializationType>()) {
-        // normal cases: using AliasFoo = Foo<T, U>;
+              RhsType->getAs<TemplateSpecializationType>()) {
+        // The template decl in the TST can be a TypeALiasTemplateDecl if
+        // the right hand side of the alias is a type alias as well. E.g.
+        //
+        // template<typename T>
+        // using AliasFoo1 = Foo<T>;  // Foo<T> is a class template specialization
+        //
+        // template<typename T>
+        // using AliasFoo2 = AliasFoo1<T>; // AliasFoo1<T> is a type alias
+        // FIXME: handle this case, we need to recursively perform deductions.
         Template = dyn_cast_or_null<ClassTemplateDecl>(
             TST->getTemplateName().getAsTemplateDecl());
         AliasRhsTemplateArgs = TST->template_arguments();
-      } else if (const auto *RT = UnderlyingType->getAs<RecordType>()) {
+      } else if (const auto *RT = RhsType->getAs<RecordType>()) {
         // cases where template arguments in the RHS of the alias are not
         // dependent. e.g.
         //   using AliasFoo = Foo<bool>;

clang/test/SemaCXX/cxx20-ctad-type-alias.cpp

@@ -1,5 +1,4 @@
 // RUN: %clang_cc1 -fsyntax-only -Wno-c++11-narrowing -Wno-literal-conversion -std=c++20 -verify %s
-// expected-no-diagnostics
 
 template<typename T>
 struct Foo {
@@ -82,3 +81,16 @@ template<typename T>
 using AF = Foo<T, 1>;
 AF b{0};//
 }
+
+namespace test7 {
+
+template<typename T>
+struct Foo { Foo(T); };
+
+template<typename U>
+using AF1 = Foo<U>;
+template<typename K>
+using AF2 = AF1<K>; // expected-note {{template is declared here}}
+// FIXME: support this case.
+AF2 b = 1; // expected-error {{alias template 'AF2' requires template arguments; argument deduction only allowed for class templates}}
+}