| // PR c++/39475 |
| |
| struct I; // { dg-message "forward declaration" } |
| struct C { }; |
| union U; // { dg-message "forward declaration" } |
| |
| bool nas1 = __has_nothrow_assign(I); // { dg-error "incomplete type" } |
| bool nas2 = __has_nothrow_assign(C[]); |
| bool nas3 = __has_nothrow_assign(I[]); |
| bool nas4 = __has_nothrow_assign(void); |
| bool nas5 = __has_nothrow_assign(const void); |
| |
| bool tas1 = __has_trivial_assign(I); // { dg-error "incomplete type" } |
| bool tas2 = __has_trivial_assign(C[]); |
| bool tas3 = __has_trivial_assign(I[]); |
| bool tas4 = __has_trivial_assign(void); |
| bool tas5 = __has_trivial_assign(const void); |
| |
| bool nco1 = __has_nothrow_constructor(I); // { dg-error "incomplete type" } |
| bool nco2 = __has_nothrow_constructor(C[]); |
| bool nco3 = __has_nothrow_constructor(I[]); |
| bool nco4 = __has_nothrow_constructor(void); |
| bool nco5 = __has_nothrow_constructor(const void); |
| |
| bool tco1 = __has_trivial_constructor(I); // { dg-error "incomplete type" } |
| bool tco2 = __has_trivial_constructor(C[]); |
| bool tco3 = __has_trivial_constructor(I[]); |
| bool tco4 = __has_trivial_constructor(void); |
| bool tco5 = __has_trivial_constructor(const void); |
| |
| bool ncp1 = __has_nothrow_copy(I); // { dg-error "incomplete type" } |
| bool ncp2 = __has_nothrow_copy(C[]); |
| bool ncp3 = __has_nothrow_copy(I[]); |
| bool ncp4 = __has_nothrow_copy(void); |
| bool ncp5 = __has_nothrow_copy(const void); |
| |
| bool tcp1 = __has_trivial_copy(I); // { dg-error "incomplete type" } |
| bool tcp2 = __has_trivial_copy(C[]); |
| bool tcp3 = __has_trivial_copy(I[]); |
| bool tcp4 = __has_trivial_copy(void); |
| bool tcp5 = __has_trivial_copy(const void); |
| |
| bool tde1 = __has_trivial_destructor(I); // { dg-error "incomplete type" } |
| bool tde2 = __has_trivial_destructor(C[]); |
| bool tde3 = __has_trivial_destructor(I[]); |
| bool tde4 = __has_trivial_destructor(void); |
| bool tde5 = __has_trivial_destructor(const void); |
| |
| // T shall be a complete type, cv void, or an array of unknown bound. |
| |
| bool con1 = __is_constructible(C); |
| bool con2 = __is_constructible(I); // { dg-error "incomplete type" } |
| bool con3 = __is_constructible(U); // { dg-error "incomplete type" } |
| bool con4 = __is_constructible(C[]); |
| bool con5 = __is_constructible(I[]); |
| bool con6 = __is_constructible(U[]); |
| bool con7 = __is_constructible(C[1]); |
| bool con8 = __is_constructible(I[1]); // { dg-error "incomplete type" } |
| bool con9 = __is_constructible(U[1]); // { dg-error "incomplete type" } |
| bool con10 = __is_constructible(void); |
| bool con11 = __is_constructible(const void); |
| |
| // If T is a non-union class type, T shall be a complete type. |
| |
| bool vde1 = __has_virtual_destructor(I); // { dg-error "incomplete type" } |
| bool vde2 = __has_virtual_destructor(U); |
| bool vde3 = __has_virtual_destructor(C[]); |
| bool vde4 = __has_virtual_destructor(I[]); |
| bool vde5 = __has_virtual_destructor(U[]); |
| bool vde6 = __has_virtual_destructor(C[1]); |
| bool vde7 = __has_virtual_destructor(I[1]); |
| bool vde8 = __has_virtual_destructor(U[1]); |
| bool vde9 = __has_virtual_destructor(void); |
| bool vde10 = __has_virtual_destructor(const void); |
| |
| bool abs1 = __is_abstract(I); // { dg-error "incomplete type" } |
| bool abs2 = __is_abstract(U); |
| bool abs3 = __is_abstract(C[]); |
| bool abs4 = __is_abstract(I[]); |
| bool abs5 = __is_abstract(U[]); |
| bool abs6 = __is_abstract(C[1]); |
| bool abs7 = __is_abstract(I[1]); |
| bool abs8 = __is_abstract(U[1]); |
| bool abs9 = __is_abstract(void); |
| bool abs10 = __is_abstract(const void); |
| |
| bool emp1 = __is_empty(I); // { dg-error "incomplete type" } |
| bool emp2 = __is_empty(U); |
| bool emp3 = __is_empty(C[]); |
| bool emp4 = __is_empty(I[]); |
| bool emp5 = __is_empty(U[]); |
| bool emp6 = __is_empty(C[1]); |
| bool emp7 = __is_empty(I[1]); |
| bool emp8 = __is_empty(U[1]); |
| bool emp9 = __is_empty(void); |
| bool emp10 = __is_empty(const void); |
| |
| bool pol1 = __is_polymorphic(I); // { dg-error "incomplete type" } |
| bool pol2 = __is_polymorphic(U); |
| bool pol3 = __is_polymorphic(C[]); |
| bool pol4 = __is_polymorphic(I[]); |
| bool pol5 = __is_polymorphic(U[]); |
| bool pol6 = __is_polymorphic(C[1]); |
| bool pol7 = __is_polymorphic(I[1]); |
| bool pol8 = __is_polymorphic(U[1]); |
| bool pol9 = __is_polymorphic(void); |
| bool pol10 = __is_polymorphic(const void); |
| |
| // If T is a class type, T shall be a complete type. |
| |
| bool agg1 = __is_aggregate(I); // { dg-error "incomplete type" } |
| bool agg2 = __is_aggregate(U); // { dg-error "incomplete type" } |
| bool agg3 = __is_aggregate(C[]); |
| bool agg4 = __is_aggregate(I[]); |
| bool agg5 = __is_aggregate(U[]); |
| bool agg6 = __is_aggregate(C[1]); |
| bool agg7 = __is_aggregate(I[1]); |
| bool agg8 = __is_aggregate(U[1]); |
| bool agg9 = __is_aggregate(void); |
| bool agg10 = __is_aggregate(const void); |
| |
| bool fin1 = __is_final(I); // { dg-error "incomplete type" } |
| bool fin2 = __is_final(U); // { dg-error "incomplete type" } |
| bool fin3 = __is_final(C[]); |
| bool fin4 = __is_final(I[]); |
| bool fin5 = __is_final(U[]); |
| bool fin6 = __is_final(C[1]); |
| bool fin7 = __is_final(I[1]); |
| bool fin8 = __is_final(U[1]); |
| bool fin9 = __is_final(void); |
| bool fin10 = __is_final(const void); |
| |
| // remove_all_extents_t<T> shall be a complete type or cv void. |
| |
| bool pod1 = __is_pod(I); // { dg-error "incomplete type" } |
| bool pod2 = __is_pod(U); // { dg-error "incomplete type" } |
| bool pod3 = __is_pod(C[]); |
| bool pod4 = __is_pod(I[]); // { dg-error "incomplete type" } |
| bool pod5 = __is_pod(U[]); // { dg-error "incomplete type" } |
| bool pod6 = __is_pod(C[1]); |
| bool pod7 = __is_pod(I[1]); // { dg-error "incomplete type" } |
| bool pod8 = __is_pod(U[1]); // { dg-error "incomplete type" } |
| bool pod9 = __is_pod(void); |
| bool pod10 = __is_pod(const void); |
