Sema: Don't erroneously reject `void{}`

[aaronpuchert]

Summary

This is explicitly allowed via [expr.type.conv], if the initialization
list is empty.

[aaronpuchert]

CC @Tyker for the changes to SemaCXX/attr-annotate.cpp.

clang/include/clang/Basic/DiagnosticSemaKinds.td

5848–5849

Might also consider it a narrowing conversion. But I can't find the standard specifically calling it that.

clang/test/CXX/expr/expr.post/expr.type.conv/p2.cpp

12

With parantheses this is (correctly) allowed:

If the initializer is a parenthesized single expression, the type conversion expression is equivalent to the corresponding cast expression.

[expr.static.cast]p6:

Any expression can be explicitly converted to type cv void, in which case it becomes a discarded-value expression ([expr.prop]).

Not sure if we need a test for that.

[rsmith]

This is CWG issue 2351. Please add a corresponding test to tests/CXX/drs/dr23xx.cpp.

clang/lib/Sema/SemaInit.cpp

1311–1319

Hm, this seems like the wrong place for this check, given the wording -- the language rule is specific to functional casts, and shouldn't apply to initialization of void-typed objects in general -- but perhaps it's the best place we have (and I think we deal with the void() case here in SemaInit too). Please at least make sure that we still properly reject things like:

void f() {
  return {};
}

We also need to decide whether to accept the compound-literal form of this:

void g() {
  (void){};
}

GCC trunk does, but I'm not sure whether that's intentional or an oversight. We certainly shouldn't accept that (without a diagnostic, at least) in C.

[shafik]

It looks like this is almost there, can we get it over the line?

[aaronpuchert]

Yeah, we should get this over the line. I'm still not quite sure where to put the check. Reading @rsmith's comment again, SemaInit might perhaps be acceptable for now, except that I should add the additional tests (in case we don't have them already).

I think we also need D113837, because otherwise void is being used as a placeholder. In any event, I should at least rebase the patches and check if they still work.

clang/lib/Sema/SemaInit.cpp

1311–1319

Hm, this seems like the wrong place for this check, given the wording -- the language rule is specific to functional casts, and shouldn't apply to initialization of void-typed objects in general -- but perhaps it's the best place we have (and I think we deal with the void() case here in SemaInit too).

So we should unconditionally allow it here and check later in CastOperation::CheckCXXCStyleCast? It handles void target types already, but only for [expr.static.cast]p6:

Any expression can be explicitly converted to type cv void, in which case it becomes a discarded-value expression ([expr.prop]).

Indeed we don't create a CXXFunctionalCastExpr for void() but a CXXScalarValueInitExpr (though probably for legacy reasons). But it should be the proper place, I agree.

Please at least make sure that we still properly reject things like:

void f() {
  return {};
}

That fails as before with

<stdin>:2:3: error: void function 'f' must not return a value
  return {};
  ^      ~~

We also need to decide whether to accept the compound-literal form of this:

void g() {
  (void){};
}

That is rejected in C and C++ with

<stdin>:2:3: error: variable has incomplete type 'void'
  (void){};
  ^~~~~~~~

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_cxx98_compat_initializer_list_init : Warning<
   "initialization of initializer_list object is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def warn_cxx98_compat_ctor_list_init : Warning<
   "constructor call from initializer list is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_illegal_initializer : Error<
   "illegal initializer (only variables can be initialized)">;
 def err_illegal_initializer_type : Error<"illegal initializer type %0">;
+def err_init_list_void_nonempty : Error<
+  "initializer list for 'void' must be empty">;
 def ext_init_list_type_narrowing : ExtWarn<
   "type %0 cannot be narrowed to %1 in initializer list">,
   InGroup<CXX11Narrowing>, DefaultError, SFINAEFailure;
 def ext_init_list_variable_narrowing : ExtWarn<
   "non-constant-expression cannot be narrowed from type %0 to %1 in "
   "initializer list">, InGroup<CXX11Narrowing>, DefaultError, SFINAEFailure;
 def ext_init_list_constant_narrowing : ExtWarn<
   "constant expression evaluates to %0 which cannot be narrowed to type %1">,

clang/lib/Sema/SemaInit.cpp

CheckStructUnionTypes(Entity, IList, DeclType, Bases, RD->field_begin(),
                           StructuredIndex, TopLevelObject);
   } else if (DeclType->isArrayType()) {
     llvm::APSInt Zero(
                     SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
                     false);
     CheckArrayType(Entity, IList, DeclType, Zero,
                    SubobjectIsDesignatorContext, Index,
                    StructuredList, StructuredIndex);
-  } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
+  } else if (DeclType->isVoidType()) {
+    // [expr.type.conv]p2: Otherwise, if the type is cv void and the
+    // initializer is () or {} (after pack expansion, if any), the expression
+    // is a prvalue of type void that performs no initialization.
+    if (IList->getNumInits() > 0) {
+      if (!VerifyOnly)
+        SemaRef.Diag(IList->getBeginLoc(), diag::err_init_list_void_nonempty);
+      hadError = true;
+    }
+  } else if (DeclType->isFunctionType()) {
     // This type is invalid, issue a diagnostic.
     ++Index;
     if (!VerifyOnly)
       SemaRef.Diag(IList->getBeginLoc(), diag::err_illegal_initializer_type)
           << DeclType;
     hadError = true;
   } else if (DeclType->isReferenceType()) {
     CheckReferenceType(Entity, IList, DeclType, Index,

clang/test/CXX/expr/expr.post/expr.type.conv/p2.cpp

+// RUN: %clang_cc1 -std=c++11 -verify %s
+
+void paren_list() {
+  return void();
+}
+
+void brace_list() {
+  return void{};
+}
+
+void brace_list_nonempty() {
+  return void{1}; // expected-error {{initializer list for 'void' must be empty}}
+}
+
+void brace_list_nested_nonempty() {
+  return void{{}}; // expected-error {{initializer list for 'void' must be empty}}
+}

clang/test/SemaCXX/attr-annotate.cpp

namespace test0 {
   A<int, 9> a;
 // expected-note@-1 {{in instantiation of template class}}
   A<long, 7> a1;
 // expected-note@-1 {{in instantiation of template class}}
   A<unsigned long, 6> a2;
 
   template<typename T>
   struct B {
-    [[clang::annotate("test", ((void)T{}, 9))]] void t() {}
-    // expected-error@-1 {{illegal initializer type 'void'}}
+    [[clang::annotate("test", ((void)T{1}, 9))]] void t() {}
+    // expected-error@-1 {{initializer list for 'void' must be empty}}
   };
   B<int> b;
   B<void> b1;
 // expected-note@-1 {{in instantiation of template class}}
 }
 
 namespace test1 {
 int g_i; // expected-note {{declared here}}

clang/test/SemaCXX/cxx2a-explicit-bool.cpp

 explicit(false) void f(int);// expected-error {{'explicit' can only be specified inside the class definition}}
 
 struct D {
   explicit(false) void f(int);// expected-error {{'explicit' can only be applied to a constructor or conversion function}}
 };
 
 template <typename T> struct E {
   // expected-note@-1+ {{candidate constructor}}
-  explicit((T{}, false))
-  // expected-error@-1 {{illegal initializer type 'void'}}
+  explicit(((T&&)T{}, false))
+  // expected-error@-1 {{cannot form a reference to 'void'}}
   E(int);
 };
 
 E<void> e = 1;
 // expected-error@-1 {{no viable conversion}}
 // expected-note@-2 {{in instantiation of}}
 
 }