[Clang][Sema] Do not try to analyze dependent alignment during -Wcast-align

[serge-sans-paille]

Summary

Fix #63007

[Fznamznon]

The change looks reasonable for me, though I'm not experienced in related code. Have you checked that it fixes the non-reduced original example?

[shafik]

clang/lib/Sema/SemaChecking.cpp

16163

Can't we just use hasDependentAlignment() which basically does this.

I am curious that we don't have to do this check in every location we use getDeclAlign

[serge-sans-paille]

Take review into account

[serge-sans-paille]

In D151753#4383602, @Fznamznon wrote:

Have you checked that it fixes the non-reduced original example?

Just did and it passes.

[serge-sans-paille]

clang/lib/Sema/SemaChecking.cpp

16163

I missed that method, thanks for point it out. I think we should be doing that check in the other reference in SemaChecking.cpp, but I failed to find a reproducer...

[serge-sans-paille]

Gentle ping :-)

[erichkeane]

Needs a release note, else LGTM.

clang/docs/ReleaseNotes.rst

 - The Fix-It emitted for unused labels used to expand to the next line, which caused
   visual oddities now that Clang shows more than one line of code snippet. This has
   been fixed and the Fix-It now only spans to the end of the ``:``.
 - Clang now underlines the parameter list of function declaration when emitting
   a note about the mismatch in the number of arguments.
 - Clang now diagnoses unexpected tokens after a
   ``#pragma clang|GCC diagnostic push|pop`` directive.
   (`#13920: <https://github.com/llvm/llvm-project/issues/13920>`_)
+- Clang now does not try to analyze cast validity on variables with dependent alignment (`#63007: <https://github.com/llvm/llvm-project/issues/63007>`_).
 
 Bug Fixes in This Version
 -------------------------
 
 - Fix segfault while running clang-rename on a non existing file.
   (`#36471 <https://github.com/llvm/llvm-project/issues/36471>`_)
 - Fix crash when diagnosing incorrect usage of ``_Nullable`` involving alias
   templates.

clang/lib/Sema/SemaChecking.cpp

 /// declaration itself, e.g., that the types of each of the function
 /// parameters are complete.
 bool Sema::CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,
                                     bool CheckParameterNames) {
   bool HasInvalidParm = false;
   for (ParmVarDecl *Param : Parameters) {
     assert(Param && "null in a parameter list");
     // C99 6.7.5.3p4: the parameters in a parameter type list in a
     // function declarator that is part of a function definition of
     // that function shall not have incomplete type.
     //
     // C++23 [dcl.fct.def.general]/p2
     // The type of a parameter [...] for a function definition
     // shall not be a (possibly cv-qualified) class type that is incomplete
     // or abstract within the function body unless the function is deleted.
     if (!Param->isInvalidDecl() &&
         (RequireCompleteType(Param->getLocation(), Param->getType(),
case Stmt::ArraySubscriptExprClass: {
     auto *ASE = cast<ArraySubscriptExpr>(E);
     return getAlignmentAndOffsetFromBinAddOrSub(ASE->getBase(), ASE->getIdx(),
                                                 false, Ctx);
   }
   case Stmt::DeclRefExprClass: {
     if (auto *VD = dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
       // FIXME: If VD is captured by copy or is an escaping __block variable,
       // use the alignment of VD's type.
-      if (!VD->getType()->isReferenceType())
+      if (!VD->getType()->isReferenceType()) {
+        // Dependent alignment cannot be resolved -> bail out.
+        if (VD->hasDependentAlignment())
+          break;
         return std::make_pair(Ctx.getDeclAlign(VD), CharUnits::Zero());
+      }
       if (VD->hasInit())
         return getBaseAlignmentAndOffsetFromLValue(VD->getInit(), Ctx);
     }
     break;
   }
   case Stmt::MemberExprClass: {
     auto *ME = cast<MemberExpr>(E);
     auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());

clang/test/SemaCXX/warn-cast-align.cpp

void test1(void *P) {
 
   c = (int*) P;
   c = static_cast<int*>(P);
   c = reinterpret_cast<int*>(P);
   typedef int *IntPtr;
   c = IntPtr(P);
 }
 
+template <class A> void DependentAlign() {
+  alignas(A) int lut[]{};
+  (long *)lut; // expected-warning {{cast from 'int *' to 'long *'}}
+}
+
 struct __attribute__((aligned(16))) AlignedS {
   char m[16];
 };
 
 struct __attribute__((aligned(16))) A {
   char m0[16];
   char m1[16];
   AlignedS *getAlignedS() {