[clang] Make variables of undeduced types to have dependent alignment

[ArcsinX]

Summary

Without this patch VarDecl::hasDependent() checks only undeduced auto types, so can give false negatives result for other undeduced types.
This lead to crashes in sequence !VarDecl::hasDepentent() => getDeclAlign().

It seems this problem appeared since D105380

[mizvekov]

LGTM

clang/lib/AST/Decl.cpp

 }
 
 bool VarDecl::isNonEscapingByref() const {
   return hasAttr<BlocksAttr>() && !NonParmVarDeclBits.EscapingByref;
 }
 
 bool VarDecl::hasDependentAlignment() const {
   QualType T = getType();
-  return T->isDependentType() || T->isUndeducedAutoType() ||
+  return T->isDependentType() || T->isUndeducedType() ||
          llvm::any_of(specific_attrs<AlignedAttr>(), [](const AlignedAttr *AA) {
            return AA->isAlignmentDependent();
          });
 }
 
 VarDecl *VarDecl::getTemplateInstantiationPattern() const {
   const VarDecl *VD = this;
 

clang/test/Sema/tls_alignment.cpp

 // TLS variable cannot be aligned to more than 32 bytes on PS4.
 
-// RUN: %clang_cc1 -triple x86_64-scei-ps4 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple x86_64-scei-ps4 -std=c++17 -fsyntax-only -verify %s
 
 
 // A non-aligned type.
 struct non_aligned_struct {
     int some_data[16]; // 64 bytes of stuff, non aligned.
 };
 
 // An aligned type.
 struct __attribute__(( aligned(64) )) aligned_struct {
     int some_data[12]; // 48 bytes of stuff, aligned to 64.
 };
 
 // A type with an aligned field.
 struct  struct_with_aligned_field {
     int some_aligned_data[12] __attribute__(( aligned(64) )); // 48 bytes of stuff, aligned to 64.
 };
 
+// A templated type
+template <typename>
+struct templated_struct {};
+// expected-note@-1{{candidate template ignored: couldn't infer template argument ''}}
+// expected-note@-2{{candidate function template not viable: requires 1 argument, but 0 were provided}}
+
 // A typedef of the aligned struct.
 typedef aligned_struct another_aligned_struct;
 
 // A typedef to redefine a non-aligned struct as aligned.
 typedef __attribute__(( aligned(64) )) non_aligned_struct yet_another_aligned_struct;
 
 // Non aligned variable doesn't cause an error.
 __thread non_aligned_struct foo;
 
 // Variable aligned because of its type should cause an error.
 __thread aligned_struct                    bar; // expected-error{{alignment (64) of thread-local variable}}
 
 // Variable explicitly aligned in the declaration should cause an error.
 __thread non_aligned_struct                bar2 __attribute__(( aligned(64) )); // expected-error{{alignment (64) of thread-local variable}}
 
 // Variable aligned because of one of its fields should cause an error.
 __thread struct_with_aligned_field         bar3; // expected-error{{alignment (64) of thread-local variable}}
 
 // Variable aligned because of typedef, first case.
 __thread another_aligned_struct            bar4; // expected-error{{alignment (64) of thread-local variable}}
 
 // Variable aligned because of typedef, second case.
 __thread yet_another_aligned_struct        bar5; // expected-error{{alignment (64) of thread-local variable}}
 
+// No crash for undeduced type.
+__thread templated_struct                  bar6; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'templated_struct'}}
+
 int baz ()
 {
     return foo.some_data[0] + bar.some_data[1] + bar2.some_data[2] +
            bar3.some_aligned_data[3] + bar4.some_data[4] +
            bar5.some_data[5];
 }