580 lines · cpp
1// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-deprecated-builtins -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++98 %s2// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-deprecated-builtins -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++11 %s3// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-deprecated-builtins -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=c++17 %s4// RUN: %clang_cc1 -fcxx-exceptions -fsyntax-only -verify -W -Wall -Wno-deprecated-builtins -Wno-unused-but-set-variable -Wrange-loop-analysis -triple arm64-linux-gnu -target-feature +sve -std=gnu++17 %s5 6namespace std {7struct type_info;8}9 10typedef __SVInt8_t svint8_t;11typedef __SVInt16_t svint16_t;12 13svint8_t global_int8; // expected-error {{non-local variable with sizeless type 'svint8_t'}}14extern svint8_t extern_int8; // expected-error {{non-local variable with sizeless type 'svint8_t'}}15static svint8_t static_int8; // expected-error {{non-local variable with sizeless type 'svint8_t'}}16__thread svint8_t thread_int8; // expected-error {{non-local variable with sizeless type 'svint8_t'}}17svint8_t *global_int8_ptr;18extern svint8_t *extern_int8_ptr;19static svint8_t *static_int8_ptr;20 21typedef svint8_t int8_typedef;22typedef svint8_t *int8_ptr_typedef;23 24int sizeof_int8 = sizeof(svint8_t); // expected-error {{invalid application of 'sizeof' to sizeless type 'svint8_t'}}25int sizeof_int8_var = sizeof(*extern_int8_ptr); // expected-error {{invalid application of 'sizeof' to sizeless type 'svint8_t'}}26int sizeof_int8_var_ptr = sizeof(extern_int8_ptr);27 28#if __cplusplus >= 201103L29int alignof_int8 = alignof(svint8_t); // expected-error {{invalid application of 'alignof' to sizeless type 'svint8_t'}}30int alignof_int8_var = alignof(*extern_int8_ptr); // expected-error {{invalid application of 'alignof' to sizeless type 'svint8_t'}} expected-warning {{GNU extension}}31int alignof_int8_var_ptr = alignof(extern_int8_ptr); // expected-warning {{GNU extension}}32#else33int alignof_int8 = _Alignof(svint8_t); // expected-error {{invalid application of 'alignof' to sizeless type 'svint8_t'}}34int alignof_int8_var = _Alignof(*extern_int8_ptr); // expected-error {{invalid application of 'alignof' to sizeless type 'svint8_t'}} expected-warning {{GNU extension}}35int alignof_int8_var_ptr = _Alignof(extern_int8_ptr); // expected-warning {{GNU extension}}36#endif37 38void pass_int8(svint8_t); // expected-note {{no known conversion}}39 40svint8_t return_int8();41 42typedef svint8_t vec_int8_a __attribute__((vector_size(64))); // expected-error {{invalid vector element type}}43typedef svint8_t vec_int8_b __attribute__((ext_vector_type(4))); // expected-error {{invalid vector element type}}44 45void dump(const volatile void *);46 47void overf(svint8_t);48void overf(svint16_t);49 50void overf8(svint8_t); // expected-note + {{not viable}}51void overf8(int); // expected-note + {{not viable}}52 53void overf16(svint16_t); // expected-note + {{not viable}}54void overf16(int); // expected-note + {{not viable}}55 56void varargs(int, ...);57 58void unused() {59 svint8_t unused_int8; // expected-warning {{unused}}60}61 62struct incomplete_struct *incomplete_ptr;63 64typedef svint8_t sizeless_array[1]; // expected-error {{array has sizeless element type}}65 66void func(int sel) {67 static svint8_t static_int8; // expected-error {{non-local variable with sizeless type 'svint8_t'}}68 69 svint8_t local_int8;70 svint16_t local_int16;71 72 svint8_t __attribute__((aligned)) aligned_int8_1; // expected-error {{'aligned' attribute cannot be applied to sizeless type 'svint8_t'}}73 svint8_t __attribute__((aligned(4))) aligned_int8_2; // expected-error {{'aligned' attribute cannot be applied to sizeless type 'svint8_t'}}74 svint8_t _Alignas(int) aligned_int8_3; // expected-error {{'_Alignas' attribute cannot be applied to sizeless type 'svint8_t'}}75 76 int _Alignas(svint8_t) aligned_int; // expected-error {{invalid application of '_Alignas' to sizeless type 'svint8_t'}}77 78 // Using pointers to sizeless data isn't wrong here, but because the79 // type is incomplete, it doesn't provide any alignment guarantees.80 _Static_assert(__atomic_is_lock_free(1, &local_int8) == __atomic_is_lock_free(1, incomplete_ptr), "");81 _Static_assert(__atomic_is_lock_free(2, &local_int8) == __atomic_is_lock_free(2, incomplete_ptr), ""); // expected-error {{static assertion expression is not an integral constant expression}}82 _Static_assert(__atomic_always_lock_free(1, &local_int8) == __atomic_always_lock_free(1, incomplete_ptr), "");83 84 local_int8; // expected-warning {{expression result unused}}85 86 (void)local_int8;87 88 local_int8, 0; // expected-warning {{left operand of comma operator has no effect}}89 90 0, local_int8; // expected-warning {{left operand of comma operator has no effect}} expected-warning {{expression result unused}}91 92 svint8_t init_int8 = local_int8;93 svint8_t bad_init_int8 = for; // expected-error {{expected expression}}94 95#if __cplusplus >= 201103L96 int empty_brace_init_int = {};97 svint8_t empty_brace_init_int8 = {};98#else99 int empty_brace_init_int = {}; // expected-error {{scalar initializer cannot be empty}}100 svint8_t empty_brace_init_int8 = {}; // expected-error {{initializer for sizeless type 'svint8_t' (aka '__SVInt8_t') cannot be empty}}101#endif102 svint8_t brace_init_int8 = {local_int8};103 svint8_t bad_brace_init_int8_1 = {local_int8, 0}; // expected-error {{excess elements in initializer for indivisible sizeless type 'svint8_t'}}104 svint8_t bad_brace_init_int8_2 = {0}; // expected-error {{rvalue of type 'int'}}105 svint8_t bad_brace_init_int8_3 = {local_int16}; // expected-error {{lvalue of type 'svint16_t'}}106 svint8_t bad_brace_init_int8_4 = {[0] = local_int8}; // expected-error-re {{initialization of non-aggregate type 'svint8_t'{{.*}} with a designated initializer list}} expected-warning {{array designators are a C99 extension}}107 svint8_t bad_brace_init_int8_5 = {{local_int8}}; // expected-warning {{too many braces around initializer}}108 svint8_t bad_brace_init_int8_6 = {{local_int8, 0}}; // expected-warning {{too many braces around initializer}}109 110 const svint8_t const_int8 = local_int8; // expected-note {{declared const here}}111 const svint8_t uninit_const_int8; // expected-error {{default initialization of an object of const type 'const svint8_t'}}112 113 volatile svint8_t volatile_int8;114 115 const volatile svint8_t const_volatile_int8 = local_int8; // expected-note {{declared const here}}116 const volatile svint8_t uninit_const_volatile_int8; // expected-error {{default initialization of an object of const type 'const volatile svint8_t'}}117 118 _Atomic svint8_t atomic_int8; // expected-error {{_Atomic cannot be applied to sizeless type 'svint8_t'}}119 __restrict svint8_t restrict_int8; // expected-error {{requires a pointer or reference}}120 121 svint8_t array_int8[1]; // expected-error {{array has sizeless element type}}122 svint8_t array_int8_init[] = {}; // expected-error {{array has sizeless element type}}123 124 bool test_int8 = init_int8; // expected-error {{cannot initialize a variable of type 'bool' with an lvalue of type 'svint8_t'}}125 126 int int_int8 = init_int8; // expected-error {{cannot initialize a variable of type 'int' with an lvalue of type 'svint8_t'}}127 128 init_int8 = local_int8;129 init_int8 = local_int16; // expected-error {{assigning to 'svint8_t' (aka '__SVInt8_t') from incompatible type 'svint16_t'}}130 init_int8 = sel; // expected-error {{assigning to 'svint8_t' (aka '__SVInt8_t') from incompatible type 'int'}}131 132 sel = local_int8; // expected-error {{assigning to 'int' from incompatible type 'svint8_t'}}133 134 local_int8 = (svint8_t)local_int8;135 local_int8 = (const svint8_t)local_int8;136 local_int8 = (svint8_t)local_int16; // expected-error {{C-style cast from 'svint16_t' (aka '__SVInt16_t') to 'svint8_t' (aka '__SVInt8_t') is not allowed}}137 local_int8 = (svint8_t)0; // expected-error {{C-style cast from 'int' to 'svint8_t' (aka '__SVInt8_t') is not allowed}}138 sel = (int)local_int8; // expected-error {{C-style cast from 'svint8_t' (aka '__SVInt8_t') to 'int' is not allowed}}139 140 init_int8 = local_int8;141 init_int8 = const_int8;142 init_int8 = volatile_int8;143 init_int8 = const_volatile_int8;144 145 const_int8 = local_int8; // expected-error {{cannot assign to variable 'const_int8' with const-qualified type 'const svint8_t'}}146 147 volatile_int8 = local_int8;148 volatile_int8 = const_int8;149 volatile_int8 = volatile_int8;150 volatile_int8 = const_volatile_int8;151 152 const_volatile_int8 = local_int8; // expected-error {{cannot assign to variable 'const_volatile_int8' with const-qualified type 'const volatile svint8_t'}}153 154 init_int8 = sel ? init_int8 : local_int8;155 init_int8 = sel ? init_int8 : const_int8;156 init_int8 = sel ? volatile_int8 : const_int8;157 init_int8 = sel ? volatile_int8 : const_volatile_int8;158 159 pass_int8(local_int8);160 pass_int8(local_int16); // expected-error {{no matching function}}161 162 local_int8 = return_int8();163 local_int16 = return_int8(); // expected-error {{assigning to 'svint16_t' (aka '__SVInt16_t') from incompatible type 'svint8_t'}}164 165 dump(&local_int8);166 dump(&const_int8);167 dump(&volatile_int8);168 dump(&const_volatile_int8);169 170 dump(&local_int8 + 1); // expected-error {{arithmetic on a pointer to sizeless type}}171 172 *&local_int8 = local_int8;173 *&const_int8 = local_int8; // expected-error {{read-only variable is not assignable}}174 *&volatile_int8 = local_int8;175 *&const_volatile_int8 = local_int8; // expected-error {{read-only variable is not assignable}}176 177 global_int8_ptr[0] = local_int8; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}}178 global_int8_ptr[1] = local_int8; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}}179 global_int8_ptr = &global_int8_ptr[2]; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}}180 181 overf(local_int8);182 overf(local_int16);183 184 overf8(local_int8);185 overf8(local_int16); // expected-error {{no matching function}}186 187 overf16(local_int8); // expected-error {{no matching function}}188 overf16(local_int16);189 190 varargs(1, local_int8, local_int16);191 192 global_int8_ptr++; // expected-error {{arithmetic on a pointer to sizeless type}}193 global_int8_ptr--; // expected-error {{arithmetic on a pointer to sizeless type}}194 ++global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}}195 --global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}}196 global_int8_ptr + 1; // expected-error {{arithmetic on a pointer to sizeless type}}197 global_int8_ptr - 1; // expected-error {{arithmetic on a pointer to sizeless type}}198 global_int8_ptr += 1; // expected-error {{arithmetic on a pointer to sizeless type}}199 global_int8_ptr -= 1; // expected-error {{arithmetic on a pointer to sizeless type}}200 global_int8_ptr - global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}}201 202 ++init_int8; // expected-error {{cannot increment value of type 'svint8_t'}}203 init_int8++; // expected-error {{cannot increment value of type 'svint8_t'}}204 --init_int8; // expected-error {{cannot decrement value of type 'svint8_t'}}205 init_int8--; // expected-error {{cannot decrement value of type 'svint8_t'}}206 !init_int8; // expected-error {{invalid argument type 'svint8_t'}}207 *init_int8; // expected-error {{indirection requires pointer operand}}208 __real init_int8; // expected-error {{invalid type 'svint8_t'}}209 __imag init_int8; // expected-error {{invalid type 'svint8_t'}}210 211 local_int8 &&init_int8; // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}212 local_int8 || init_int8; // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}213 214 if (local_int8) { // expected-error {{not contextually convertible to 'bool'}}215 }216 while (local_int8) { // expected-error {{not contextually convertible to 'bool'}}217 }218 do {219 } while (local_int8); // expected-error {{not contextually convertible to 'bool'}}220 switch (local_int8) { // expected-error {{statement requires expression of integer type}}221 default:;222 }223}224 225int vararg_receiver(int count, svint8_t first, ...) {226 __builtin_va_list va;227 228 __builtin_va_start(va, first);229 __builtin_va_arg(va, svint8_t);230 __builtin_va_end(va);231 return count;232}233 234struct sized_struct {235 int f1;236 svint8_t f2; // expected-error {{field has sizeless type 'svint8_t'}}237 svint8_t f3 : 2; // expected-error {{field has sizeless type 'svint8_t'}}238 svint8_t : 3; // expected-error {{field has sizeless type 'svint8_t'}}239};240 241union sized_union {242 int f1;243 svint8_t f2; // expected-error {{field has sizeless type 'svint8_t'}}244 svint8_t f3 : 2; // expected-error {{field has sizeless type 'svint8_t'}}245 svint8_t : 3; // expected-error {{field has sizeless type 'svint8_t'}}246};247 248void pass_int8_ref(svint8_t &); // expected-note {{not viable}}249 250svint8_t &return_int8_ref();251#if __cplusplus >= 201103L252svint8_t &&return_int8_rvalue_ref();253#endif254 255template <typename T>256struct s_template {257 T y; // expected-error {{field has sizeless type '__SVInt8_t'}}258};259 260template <typename T>261struct s_ptr_template {262 s_ptr_template();263 s_ptr_template(T, svint8_t = svint8_t());264 s_ptr_template(const s_ptr_template &, svint8_t = svint8_t());265 T *y;266};267 268template <typename T>269struct s_array_template {270 T y[1]; // expected-error {{array has sizeless element type}}271};272 273struct widget {274 widget(s_ptr_template<int>);275 svint8_t operator[](int);276};277 278template <typename T>279struct wrapper_iterator {280 T operator++();281 T operator*() const;282 bool operator!=(const wrapper_iterator &) const;283};284 285template <typename T>286struct wrapper {287 wrapper();288 operator T() const;289 wrapper_iterator<T> begin() const;290 wrapper_iterator<T> end() const;291};292 293#if __cplusplus >= 201103L294struct explicit_conv {295 explicit operator svint8_t() const; // expected-note {{explicit conversion function is not a candidate}}296};297#endif298 299struct constructible_from_sizeless {300 constructible_from_sizeless(svint8_t);301};302 303void with_default(svint8_t = svint8_t());304 305#if __cplusplus >= 201103L306constexpr int ce_taking_int8(svint8_t) { return 1; } // expected-error {{constexpr function's 1st parameter type 'svint8_t' (aka '__SVInt8_t') is not a literal type}}307#endif308 309#if __cplusplus < 201703L310void throwing_func() throw(svint8_t); // expected-error {{sizeless type 'svint8_t' (aka '__SVInt8_t') is not allowed in exception specification}}311void throwing_pointer_func() throw(svint8_t *);312void throwing_reference_func() throw(svint8_t &); // expected-error {{reference to sizeless type 'svint8_t' (aka '__SVInt8_t') is not allowed in exception specification}}313#endif314 315template <typename T>316void template_fn_direct(T) {}317template <typename T>318void template_fn_ref(T &) {}319template <typename T>320void template_fn_const_ref(const T &) {}321#if __cplusplus >= 201103L322template <typename T>323void template_fn_rvalue_ref(T &&) {}324#endif325 326#if __cplusplus >= 201103L327template <typename T>328using array_alias = T[1]; // expected-error {{array has sizeless element type 'svint8_t' (aka '__SVInt8_t')}}329extern array_alias<int> *array_alias_int_ptr;330extern array_alias<svint8_t> *array_alias_int8_ptr; // expected-note {{in instantiation of template type alias 'array_alias' requested here}}331#endif332 333extern "C" svint8_t c_return_int8();334 335void cxx_only(int sel) {336 svint8_t local_int8;337 svint16_t local_int16;338 339 pass_int8_ref(local_int8);340 pass_int8_ref(local_int16); // expected-error {{no matching function}}341 342 local_int8 = return_int8_ref();343 local_int16 = return_int8_ref(); // expected-error {{assigning to 'svint16_t' (aka '__SVInt16_t') from incompatible type 'svint8_t'}}344 return_int8_ref() = local_int8;345 return_int8_ref() = local_int16; // expected-error {{assigning to 'svint8_t' (aka '__SVInt8_t') from incompatible type 'svint16_t'}}346 347#if __cplusplus >= 201103L348 local_int8 = return_int8_rvalue_ref();349 local_int16 = return_int8_rvalue_ref(); // expected-error {{assigning to 'svint16_t' (aka '__SVInt16_t') from incompatible type 'svint8_t'}}350 351 return_int8_rvalue_ref() = local_int8; // expected-error {{expression is not assignable}}352 return_int8_rvalue_ref() = local_int16; // expected-error {{expression is not assignable}}353#endif354 355 local_int8 = static_cast<svint8_t>(local_int8);356 local_int8 = static_cast<svint8_t>(local_int16); // expected-error {{static_cast from 'svint16_t' (aka '__SVInt16_t') to 'svint8_t' (aka '__SVInt8_t') is not allowed}}357 local_int8 = static_cast<svint8_t>(0); // expected-error {{static_cast from 'int' to 'svint8_t' (aka '__SVInt8_t') is not allowed}}358 local_int16 = static_cast<svint16_t>(local_int8); // expected-error {{static_cast from 'svint8_t' (aka '__SVInt8_t') to 'svint16_t' (aka '__SVInt16_t') is not allowed}}359 sel = static_cast<int>(local_int8); // expected-error {{static_cast from 'svint8_t' (aka '__SVInt8_t') to 'int' is not allowed}}360 361 throw local_int8; // expected-error {{cannot throw object of sizeless type 'svint8_t'}}362 throw global_int8_ptr;363 364 try {365 } catch (int) {366 }367 try {368 } catch (svint8_t) { // expected-error {{cannot catch sizeless type 'svint8_t'}}369 }370 try {371 } catch (svint8_t *) {372 }373 try {374 } catch (svint8_t &) { // expected-error {{cannot catch reference to sizeless type 'svint8_t'}}375 }376 377 new svint8_t; // expected-error {{allocation of sizeless type 'svint8_t'}}378 new svint8_t(); // expected-error {{allocation of sizeless type 'svint8_t'}}379 new svint8_t[10]; // expected-error {{allocation of sizeless type 'svint8_t'}}380 new svint8_t *;381 382 new (global_int8_ptr) svint8_t; // expected-error {{allocation of sizeless type 'svint8_t'}}383 new (global_int8_ptr) svint8_t(); // expected-error {{allocation of sizeless type 'svint8_t'}}384 new (global_int8_ptr) svint8_t[10]; // expected-error {{allocation of sizeless type 'svint8_t'}}385 386 delete global_int8_ptr; // expected-error {{cannot delete expression of type 'svint8_t *'}}387 delete[] global_int8_ptr; // expected-error {{cannot delete expression of type 'svint8_t *'}}388 389 local_int8.~__SVInt8_t(); // expected-error {{object expression of non-scalar type 'svint8_t' (aka '__SVInt8_t') cannot be used in a pseudo-destructor expression}}390 391 (void)svint8_t();392 393 local_int8 = svint8_t();394 local_int8 = svint16_t(); // expected-error {{assigning to 'svint8_t' (aka '__SVInt8_t') from incompatible type 'svint16_t'}}395 396 s_template<int> st_int;397 s_template<svint8_t> st_svint8; // expected-note {{in instantiation}}398 399 s_ptr_template<int> st_ptr_int;400 s_ptr_template<svint8_t> st_ptr_svint8;401 402 widget w(1);403 local_int8 = w[1];404 405 s_array_template<int> st_array_int;406 s_array_template<svint8_t> st_array_svint8; // expected-note {{in instantiation}}407 408 local_int8 = static_cast<svint8_t>(wrapper<svint8_t>());409 local_int16 = static_cast<svint8_t>(wrapper<svint8_t>()); // expected-error {{assigning to 'svint16_t' (aka '__SVInt16_t') from incompatible type 'svint8_t'}}410 411 local_int8 = wrapper<svint8_t>();412 local_int16 = wrapper<svint8_t>(); // expected-error {{assigning to 'svint16_t' (aka '__SVInt16_t') from incompatible type 'wrapper<svint8_t>'}}413 414 svint8_t &ref_int8 = local_int8;415 ref_int8 = ref_int8; // expected-warning {{explicitly assigning value of variable of type 'svint8_t' (aka '__SVInt8_t') to itself}}416 ref_int8 = local_int8;417 local_int8 = ref_int8;418 419#if __cplusplus >= 201103L420 svint8_t zero_init_int8{};421 svint8_t init_int8{local_int8};422 svint8_t bad_brace_init_int8_1{local_int8, 0}; // expected-error {{excess elements in initializer for indivisible sizeless type 'svint8_t'}}423 svint8_t bad_brace_init_int8_2{0}; // expected-error {{rvalue of type 'int'}}424 svint8_t bad_brace_init_int8_3{local_int16}; // expected-error {{lvalue of type 'svint16_t'}}425 svint8_t bad_brace_init_int8_4{[0] = local_int8}; // expected-error-re {{initialization of non-aggregate type 'svint8_t'{{.*}} with a designated initializer list}} expected-warning {{array designators are a C99 extension}}426 svint8_t bad_brace_init_int8_5{{local_int8}}; // expected-warning {{too many braces around initializer}}427 svint8_t bad_brace_init_int8_6{{local_int8, 0}}; // expected-warning {{too many braces around initializer}}428 svint8_t wrapper_init_int8{wrapper<svint8_t>()};429 svint8_t &ref_init_int8{local_int8};430 431 template_fn_direct<svint8_t>({wrapper<svint8_t>()});432#endif433 434 template_fn_direct(local_int8);435 template_fn_ref(local_int8);436 template_fn_const_ref(local_int8);437#if __cplusplus >= 201103L438 template_fn_rvalue_ref(local_int8);439#endif440 441#if __cplusplus >= 201103L442 constexpr svint8_t ce_int8_a = wrapper<svint8_t>(); // expected-error {{constexpr variable cannot have non-literal type 'const svint8_t'}}443#endif444 445 (void)typeid(__SVInt8_t);446 (void)typeid(__SVInt8_t *);447 (void)typeid(local_int8);448 (void)typeid(ref_int8);449 (void)typeid(static_int8_ptr);450 451 _Static_assert(__is_trivially_copyable(svint8_t), "");452 _Static_assert(__is_trivially_destructible(svint8_t), "");453 _Static_assert(!__is_nothrow_assignable(svint8_t, svint8_t), "");454 _Static_assert(__is_nothrow_assignable(svint8_t &, svint8_t), "");455 _Static_assert(!__is_nothrow_assignable(svint8_t &, svint16_t), "");456 _Static_assert(__is_constructible(svint8_t), "");457 _Static_assert(__is_constructible(svint8_t, svint8_t), "");458 _Static_assert(!__is_constructible(svint8_t, svint8_t, svint8_t), "");459 _Static_assert(!__is_constructible(svint8_t, svint16_t), "");460 _Static_assert(__is_nothrow_constructible(svint8_t), "");461 _Static_assert(__is_nothrow_constructible(svint8_t, svint8_t), "");462 _Static_assert(!__is_nothrow_constructible(svint8_t, svint16_t), "");463 _Static_assert(!__is_assignable(svint8_t, svint8_t), "");464 _Static_assert(__is_assignable(svint8_t &, svint8_t), "");465 _Static_assert(!__is_assignable(svint8_t &, svint16_t), "");466 _Static_assert(__has_nothrow_assign(svint8_t), "");467 _Static_assert(__has_nothrow_move_assign(svint8_t), "");468 _Static_assert(__has_nothrow_copy(svint8_t), "");469 _Static_assert(__has_nothrow_constructor(svint8_t), "");470 _Static_assert(__has_trivial_assign(svint8_t), "");471 _Static_assert(__has_trivial_move_assign(svint8_t), "");472 _Static_assert(__has_trivial_copy(svint8_t), "");473 _Static_assert(__has_trivial_constructor(svint8_t), "");474 _Static_assert(__has_trivial_move_constructor(svint8_t), "");475 _Static_assert(__has_trivial_destructor(svint8_t), "");476 _Static_assert(!__has_virtual_destructor(svint8_t), "");477 _Static_assert(!__is_abstract(svint8_t), "");478 _Static_assert(!__is_aggregate(svint8_t), "");479 _Static_assert(!__is_base_of(svint8_t, svint8_t), "");480 _Static_assert(!__is_class(svint8_t), "");481 _Static_assert(__is_convertible_to(svint8_t, svint8_t), "");482 _Static_assert(!__is_convertible_to(svint8_t, svint16_t), "");483 _Static_assert(!__is_empty(svint8_t), "");484 _Static_assert(!__is_enum(svint8_t), "");485 _Static_assert(!__is_final(svint8_t), "");486 _Static_assert(!__is_literal(svint8_t), "");487 _Static_assert(__is_pod(svint8_t), "");488 _Static_assert(!__is_polymorphic(svint8_t), "");489 _Static_assert(__is_trivial(svint8_t), "");490 _Static_assert(__is_object(svint8_t), "");491 _Static_assert(!__is_arithmetic(svint8_t), "");492 _Static_assert(!__is_floating_point(svint8_t), "");493 _Static_assert(!__is_integral(svint8_t), "");494 _Static_assert(!__is_void(svint8_t), "");495 _Static_assert(!__is_array(svint8_t), "");496 _Static_assert(!__is_function(svint8_t), "");497 _Static_assert(!__is_reference(svint8_t), "");498 _Static_assert(__is_reference(svint8_t &), "");499 _Static_assert(__is_reference(const svint8_t &), "");500 _Static_assert(!__is_lvalue_reference(svint8_t), "");501 _Static_assert(__is_lvalue_reference(svint8_t &), "");502#if __cplusplus >= 201103L503 _Static_assert(!__is_lvalue_reference(svint8_t &&), "");504#endif505 _Static_assert(!__is_rvalue_reference(svint8_t), "");506 _Static_assert(!__is_rvalue_reference(svint8_t &), "");507#if __cplusplus >= 201103L508 _Static_assert(__is_rvalue_reference(svint8_t &&), "");509#endif510 _Static_assert(!__is_fundamental(svint8_t), "");511 _Static_assert(__is_object(svint8_t), "");512 _Static_assert(!__is_scalar(svint8_t), "");513 _Static_assert(!__is_compound(svint8_t), "");514 _Static_assert(!__is_pointer(svint8_t), "");515 _Static_assert(__is_pointer(svint8_t *), "");516 _Static_assert(!__is_member_object_pointer(svint8_t), "");517 _Static_assert(!__is_member_function_pointer(svint8_t), "");518 _Static_assert(!__is_member_pointer(svint8_t), "");519 _Static_assert(!__is_const(svint8_t), "");520 _Static_assert(__is_const(const svint8_t), "");521 _Static_assert(__is_const(const volatile svint8_t), "");522 _Static_assert(!__is_volatile(svint8_t), "");523 _Static_assert(__is_volatile(volatile svint8_t), "");524 _Static_assert(__is_volatile(const volatile svint8_t), "");525 _Static_assert(!__is_standard_layout(svint8_t), "");526 // At present these types are opaque and don't have the properties527 // implied by their name.528 _Static_assert(!__is_signed(svint8_t), "");529 _Static_assert(!__is_unsigned(svint8_t), "");530 531#if __cplusplus >= 201103L532 auto auto_int8 = local_int8;533 auto auto_int16 = local_int16;534#if __cplusplus >= 201703L535 auto [auto_int8_a] = local_int8; // expected-error {{cannot bind non-class, non-array type 'svint8_t' (aka '__SVInt8_t')}}536#endif537#endif538 539 s_ptr_template<int> y;540 s_ptr_template<int> &x = y;541 542 constructible_from_sizeless cfs1(local_int8);543 constructible_from_sizeless cfs2 = local_int8;544#if __cplusplus >= 201103L545 constructible_from_sizeless cfs3{local_int8};546#endif547 548#if __cplusplus >= 201103L549 local_int8 = ([]() { return svint8_t(); })();550 local_int8 = ([]() -> svint8_t { return svint8_t(); })();551 auto fn1 = [&local_int8](svint8_t x) { local_int8 = x; };552 auto fn2 = [&local_int8](svint8_t *ptr) { *ptr = local_int8; };553#if __cplusplus >= 201703L554 auto fn3 = [a(return_int8())] {}; // expected-error {{field has sizeless type 'svint8_t' (aka '__SVInt8_t')}}555#endif556 auto fn4 = [local_int8](svint8_t *ptr) { *ptr = local_int8; }; // expected-error {{by-copy capture of variable 'local_int8' with sizeless type 'svint8_t'}}557 558 for (auto x : local_int8) { // expected-error {{no viable 'begin' function available}}559 }560 for (auto x : wrapper<svint8_t>()) {561 (void)x;562 }563 for (const svint8_t &x : wrapper<svint8_t>()) { // expected-warning {{loop variable 'x' binds to a temporary value produced by a range of type 'wrapper<svint8_t>'}} expected-note {{use non-reference type}}564 (void)x;565 }566 for (const svint8_t x : wrapper<const svint8_t &>()) {567 (void)x;568 }569#endif570}571 572#if __cplusplus >= 201103L573svint8_t ret_bad_conv() { return explicit_conv(); } // expected-error {{no viable conversion from returned value of type 'explicit_conv' to function return type 'svint8_t'}}574 575#pragma clang diagnostic warning "-Wc++98-compat"576 577void incompat_init() { __attribute__((unused)) svint8_t foo = {}; } // expected-warning {{initializing 'svint8_t' (aka '__SVInt8_t') from an empty initializer list is incompatible with C++98}}578 579#endif580