Fix PR48889: assertion failure for void() in flattened ternary expression

[aaronpuchert]

Summary

We treat the expression void() as CXXScalarValueInitExpr for historic
reasons probably, but void isn't a scalar type. The current standard
considers this a functional cast expression, where void is explicitly
exempted from initialization.

[aaronpuchert]

Replace E->getType() argument by T.

[rsmith]

clang/lib/CodeGen/CGExprScalar.cpp

474–475

Would it make sense to put this check in EmitNullValue instead? That would also cover an InitListExpr for void{} (which we currently appear to incorrectly reject), and an ImplicitValueInit for type void (which I don't think can be created legitimately at the moment, but that could just be a failure of imagination on my part).

[aaronpuchert]

clang/lib/CodeGen/CGExprScalar.cpp

474–475

You're right, we do reject void{}. Perhaps something I should address first, so that we can have tests for both cases.

I was considering putting this in EmitNullValue, but then I read through the standard and it seems void isn't value/zero-initializable. Then I found [expr.type.conv] where it says void() is allowed and “performs no initialization.” So if we stick close to the standard it seems we should catch the special case here, but in EmitNullValue it would indeed cover both void() and void{}.

Regarding void{}: you might know that InitListExprs have void type initially, and there is an assertion that it doesn't have void type after Sema ran over it. I'd have to remove that assertion, unless we give InitListExprs a different initial type. Maybe you can comment on D98664 what you think about this, where I'm trying to bring ParenListExpr in line with InitListExpr regarding the initial type.

[aaronpuchert]

Also fix code generation for void{}.

[shafik]

This is accepted but it looks like we need the previous void{} fix in order to land this. It would be nice to get both in before phab is not usable anymore.

clang/lib/CodeGen/CGExprScalar.cpp

public:
   }
   Value *VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
     return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
   }
   Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
     return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
   }
   Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
     return EmitNullValue(E->getType());
   }
   Value *VisitGNUNullExpr(const GNUNullExpr *E) {
     return EmitNullValue(E->getType());
   }
   Value *VisitOffsetOfExpr(OffsetOfExpr *E);
   Value *VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
   Value *VisitAddrLabelExpr(const AddrLabelExpr *E) {
     llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel());
     return Builder.CreateBitCast(V, ConvertType(E->getType()));
Value *ScalarExprEmitter::EmitComplexToScalarConversion(
   // C99 6.3.1.7p2: "When a value of complex type is converted to a real type,
   // the imaginary part of the complex value is discarded and the value of the
   // real part is converted according to the conversion rules for the
   // corresponding real type.
   return EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
 }
 
 Value *ScalarExprEmitter::EmitNullValue(QualType Ty) {
+  // [expr.type.conv]: if the type is cv void and the initializer is () or {},
+  // the expression is a prvalue of type void that performs no initialization.
+  if (Ty->isVoidType())
+    return nullptr;
   return CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(Ty), Ty);
 }
 
 /// Emit a sanitization check for the given "binary" operation (which
 /// might actually be a unary increment which has been lowered to a binary
 /// operation). The check passes if all values in \p Checks (which are \c i1),
 /// are \c true.
 void ScalarExprEmitter::EmitBinOpCheck(

clang/test/CodeGenCXX/value-init.cpp

 
 #if __cplusplus >= 201103L
 namespace transparent_init_list {
   struct optional_assign_base {};
   struct optional_data_dtor_base { char dummy_[24]; };
   struct optional : optional_data_dtor_base, optional_assign_base {};
   optional f(optional a) { return {optional(a)}; }
 }
+
+namespace PR48889 {
+  // Just make sure we don't hit an assertion, the IR is otherwise unchanged.
+  constexpr void f() {}
+  void paren_list(bool b) {
+    return b ? f() : void();
+  }
+  void braced_list(bool b) {
+    return b ? f() : void{};
+  }
+}
 #endif