[clang] Fix Complex x Float x Int conversions so it handles type sugar

[mizvekov]

Summary

The included test case was broken by D111509 since now
those types can have sugar.

Replace dyn_casts / cast and small refactor to preserve sugar by
not stripping it down when type is already Complex.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

I just included a similar fix for another problem I found inspecting nearby code for the same kind of bug:

typedef __complex__ float ComplexFloat;
int cc = 1 + (ComplexFloat)(1.0iF);

[ronlieb]

hopefully will fix this ?
invalid cast kind for complex value
UNREACHABLE executed at /clang/lib/AST/ExprConstant.cpp:14263!
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace, preprocessed source, and as
sociated run script.

[mizvekov]

In D133522#3778655, @ronlieb wrote:

hopefully will fix this ?
invalid cast kind for complex value
UNREACHABLE executed at /clang/lib/AST/ExprConstant.cpp:14263!
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace, preprocessed source, and as
sociated run script.

That looks like a different problem, haven't seen a reproducer yet. Are you able to share it?

[ronlieb]

emailed a hopeful reproducer to you

[mizvekov]

In D133522#3778693, @ronlieb wrote:

emailed a hopeful reproducer to you

Thanks, seen!

Going to start running creduce on it.

[tra]

I can confirm that this patch does address the compiler crash seen on CUDA build bots. I'm not familiar enough with the code to review it otherwise.

[mizvekov]

Since the affected patch just got reverted, I will squash these fixes in the original MR instead.

[mizvekov]

In D133522#3778693, @ronlieb wrote:

emailed a hopeful reproducer to you

I reduced it and confirm it was also fixed by this patch.

[shafik]

clang/lib/Sema/SemaExpr.cpp

1135

Can you collapse this check with the next line? It just looks weird checking RHSComplexType twice and having RHSType on the opposite side of each one. It took me a while to understand what was going on.

This comment also applies a few lines down.

[mizvekov]

clang/lib/Sema/SemaExpr.cpp

1135

I have refactored the whole thing, but at D111509

The present patch was intended to be a quick fix to that one, to avoid reverting it, but that is moot now since it ended up reverted and we can't test what is in here without the other one.

clang/lib/Sema/SemaExpr.cpp

 static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr,
                                                   ExprResult &ComplexExpr,
                                                   QualType IntTy,
                                                   QualType ComplexTy,
                                                   bool SkipCast) {
   if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true;
   if (SkipCast) return false;
   if (IntTy->isIntegerType()) {
-    QualType fpTy = cast<ComplexType>(ComplexTy)->getElementType();
+    QualType fpTy = ComplexTy->castAs<ComplexType>()->getElementType();
     IntExpr = S.ImpCastExprToType(IntExpr.get(), fpTy, CK_IntegralToFloating);
     IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
                                   CK_FloatingRealToComplex);
   } else {
     assert(IntTy->isComplexIntegerType());
     IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
                                   CK_IntegralComplexToFloatingComplex);
   }
   return false;
 }
 
 /// Handle arithmetic conversion with complex types.  Helper function of
 /// UsualArithmeticConversions()
 static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS,
                                              ExprResult &RHS, QualType LHSType,
                                              QualType RHSType,
                                              bool IsCompAssign) {
   // if we have an integer operand, the result is the complex type.
   if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType,
-                                             /*skipCast*/false))
+                                             /*SkipCast=*/false))
     return LHSType;
   if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType,
-                                             /*skipCast*/IsCompAssign))
+                                             /*SkipCast=*/IsCompAssign))
     return RHSType;
 
   // This handles complex/complex, complex/float, or float/complex.
   // When both operands are complex, the shorter operand is converted to the
   // type of the longer, and that is the type of the result. This corresponds
   // to what is done when combining two real floating-point operands.
   // The fun begins when size promotion occur across type domains.
   // From H&S 6.3.4: When one operand is complex and the other is a real
   // floating-point type, the less precise type is converted, within it's
   // real or complex domain, to the precision of the other type. For example,
   // when combining a "long double" with a "double _Complex", the
   // "double _Complex" is promoted to "long double _Complex".
 
+  auto *LHSComplexType = LHSType->getAs<ComplexType>();
+  auto *RHSComplexType = RHSType->getAs<ComplexType>();
+
   // Compute the rank of the two types, regardless of whether they are complex.
   int Order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
-
-  auto *LHSComplexType = dyn_cast<ComplexType>(LHSType);
-  auto *RHSComplexType = dyn_cast<ComplexType>(RHSType);
-  QualType LHSElementType =
-      LHSComplexType ? LHSComplexType->getElementType() : LHSType;
+  if (Order < 0) {
     QualType RHSElementType =
         RHSComplexType ? RHSComplexType->getElementType() : RHSType;
-
-  QualType ResultType = S.Context.getComplexType(LHSElementType);
-  if (Order < 0) {
+    QualType ResultType =
+        RHSComplexType ? RHSType : S.Context.getComplexType(RHSElementType);
     // Promote the precision of the LHS if not an assignment.
-    ResultType = S.Context.getComplexType(RHSElementType);
     if (!IsCompAssign) {
       if (LHSComplexType)
         LHS =
             S.ImpCastExprToType(LHS.get(), ResultType, CK_FloatingComplexCast);
       else
         LHS = S.ImpCastExprToType(LHS.get(), RHSElementType, CK_FloatingCast);
     }
-  } else if (Order > 0) {
+    return ResultType;
+  }
+  QualType LHSElementType =
+      LHSComplexType ? LHSComplexType->getElementType() : LHSType;
+  QualType ResultType =
+      LHSComplexType ? LHSType : S.Context.getComplexType(LHSElementType);
+  if (Order > 0) {
     // Promote the precision of the RHS.
     if (RHSComplexType)
       RHS = S.ImpCastExprToType(RHS.get(), ResultType, CK_FloatingComplexCast);
     else
       RHS = S.ImpCastExprToType(RHS.get(), LHSElementType, CK_FloatingCast);
   }
   return ResultType;
 }

clang/test/Sema/complex-int.c

 // RUN: %clang_cc1 %s -verify -fsyntax-only
 
 void a(void) {
 __complex__ int arr;
 __complex__ short brr;
 __complex__ unsigned xx;
 __complex__ signed yy;
 __complex__ int result;
 int ii;
 int aa = 1 + 1.0iF;
 int bb = 0;
 bb += 1i;
 
+typedef __complex__ float ComplexFloat;
+int cc = 1 + (ComplexFloat)(1.0iF);
+
 result = arr*ii;
 result = ii*brr;
 
 result = arr*brr;
 result = xx*yy;
 
 switch (arr) { // expected-error{{statement requires expression of integer type ('_Complex int' invalid)}}
   case brr: ; // expected-error{{integer constant expression must have integer type}}

clang/test/SemaCXX/complex-conversion.cpp

void func(float Real, _Complex float Complex) {
   Real = (float)Complex;
 
   take<float>(Complex); // expected-error {{implicit conversion from '_Complex float' to 'float' is not permitted in C++}}
   take<double>(1.0i); // expected-error {{implicit conversion from '_Complex double' to 'double' is not permitted in C++}}
   take<_Complex float>(Complex);
 
   // Conversion to bool doesn't actually discard the imaginary part.
   take<bool>(Complex);
+
+  using B = _Complex double;
+  B c;
+  c *= double();
 }