[Clang][Sema] Avoid crashing for va_arg expressions with bool argument

[egorzhdan]

Summary

This change fixes a compiler crash that was introduced in https://reviews.llvm.org/D103611: Sema::BuildVAArgExpr attempted to retrieve a corresponding signed type for bool by calling ASTContext::getCorrespondingSignedType.

rdar://86580370

[aaron.ballman]

LGTM, thank you for the fix!

I think this would also be a reasonable candidate for a 13.0.X release, in case you wanted to file an issue to backport it. I think 13.0.1 may be too late to hit though. CCing @tstellar just in case.

[egorzhdan]

Thank you @aaron.ballman, I will try to get this patch into the next 13.0.x release.

[tstellar]

We may have time to fit it in to the release, but no guarantees. Can you file an issue for this?

[egorzhdan]

In D116272#3228427, @tstellar wrote:

We may have time to fit it in to the release, but no guarantees. Can you file an issue for this?

That would be great. I filed an issue: https://github.com/llvm/llvm-project/issues/53078.

clang/lib/Sema/SemaExpr.cpp

if (TInfo->getType()->isPromotableIntegerType()) {
       if (Context.typesAreCompatible(PromoteType, UnderlyingType,
                                      /*CompareUnqualified*/ true))
         PromoteType = QualType();
 
       // If the types are still not compatible, we need to test whether the
       // promoted type and the underlying type are the same except for
       // signedness. Ask the AST for the correctly corresponding type and see
       // if that's compatible.
-      if (!PromoteType.isNull() &&
+      if (!PromoteType.isNull() && !UnderlyingType->isBooleanType() &&
           PromoteType->isUnsignedIntegerType() !=
               UnderlyingType->isUnsignedIntegerType()) {
         UnderlyingType =
             UnderlyingType->isUnsignedIntegerType()
                 ? Context.getCorrespondingSignedType(UnderlyingType)
                 : Context.getCorrespondingUnsignedType(UnderlyingType);
         if (Context.typesAreCompatible(PromoteType, UnderlyingType,
                                        /*CompareUnqualified*/ true))

clang/test/SemaCXX/varargs.cpp

void promotable(int a, ...) {
   enum FixedLarge : long long { Six };
   (void)__builtin_va_arg(ap, FixedLarge); // ok
 
   // Ensure that qualifiers are ignored.
   (void)__builtin_va_arg(ap, const volatile int);  // ok
 
   // Ensure that signed vs unsigned doesn't matter either.
   (void)__builtin_va_arg(ap, unsigned int);
+
+  (void)__builtin_va_arg(ap, bool); // expected-warning {{second argument to 'va_arg' is of promotable type 'bool'; this va_arg has undefined behavior because arguments will be promoted to 'int'}}
 }
 
 #if __cplusplus >= 201103L
 // We used to have bugs identifying the correct enclosing function scope in a
 // lambda.
 
 void fixed_lambda_varargs_function(int a, ...) {
   [](int b) {