clang/test/SemaCXX/sizeless-1.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 %s
   2 // 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 %s
   3 // 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 %s
   4 // 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 %s
   5
   6 namespace std {
   7 struct type_info;
   8 }
   9
  10 typedef __SVInt8_t svint8_t;
  11 typedef __SVInt16_t svint16_t;
  12
  13 svint8_t global_int8;          // expected-error {{non-local variable with sizeless type 'svint8_t'}}
  14 extern svint8_t extern_int8;   // expected-error {{non-local variable with sizeless type 'svint8_t'}}
  15 static 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'}}
  17 svint8_t *global_int8_ptr;
  18 extern svint8_t *extern_int8_ptr;
  19 static svint8_t *static_int8_ptr;
  20
  21 typedef svint8_t int8_typedef;
  22 typedef svint8_t *int8_ptr_typedef;
  23
  24 int sizeof_int8 = sizeof(svint8_t);             // expected-error {{invalid application of 'sizeof' to sizeless type 'svint8_t'}}
  25 int sizeof_int8_var = sizeof(*extern_int8_ptr); // expected-error {{invalid application of 'sizeof' to sizeless type 'svint8_t'}}
  26 int sizeof_int8_var_ptr = sizeof(extern_int8_ptr);
  27
  28 #if __cplusplus >= 201103L
  29 int alignof_int8 = alignof(svint8_t);                // expected-error {{invalid application of 'alignof' to sizeless type 'svint8_t'}}
  30 int alignof_int8_var = alignof(*extern_int8_ptr);    // expected-error {{invalid application of 'alignof' to sizeless type 'svint8_t'}} expected-warning {{GNU extension}}
  31 int alignof_int8_var_ptr = alignof(extern_int8_ptr); // expected-warning {{GNU extension}}
  32 #else
  33 int alignof_int8 = _Alignof(svint8_t);                // expected-error {{invalid application of 'alignof' to sizeless type 'svint8_t'}}
  34 int alignof_int8_var = _Alignof(*extern_int8_ptr);    // expected-error {{invalid application of 'alignof' to sizeless type 'svint8_t'}} expected-warning {{GNU extension}}
  35 int alignof_int8_var_ptr = _Alignof(extern_int8_ptr); // expected-warning {{GNU extension}}
  36 #endif
  37
  38 void pass_int8(svint8_t); // expected-note {{no known conversion}}
  39
  40 svint8_t return_int8();
  41
  42 typedef svint8_t vec_int8_a __attribute__((vector_size(64)));    // expected-error {{invalid vector element type}}
  43 typedef svint8_t vec_int8_b __attribute__((ext_vector_type(4))); // expected-error {{invalid vector element type}}
  44
  45 void dump(const volatile void *);
  46
  47 void overf(svint8_t);
  48 void overf(svint16_t);
  49
  50 void overf8(svint8_t); // expected-note + {{not viable}}
  51 void overf8(int);      // expected-note + {{not viable}}
  52
  53 void overf16(svint16_t); // expected-note + {{not viable}}
  54 void overf16(int);       // expected-note + {{not viable}}
  55
  56 void varargs(int, ...);
  57
  58 void unused() {
  59   svint8_t unused_int8; // expected-warning {{unused}}
  60 }
  61
  62 struct incomplete_struct *incomplete_ptr;
  63
  64 typedef svint8_t sizeless_array[1]; // expected-error {{array has sizeless element type}}
  65
  66 void 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 the
  79   // 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 >= 201103L
  96   int empty_brace_init_int = {};
  97   svint8_t empty_brace_init_int8 = {};
  98 #else
  99   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 #endif
 102   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
 225 int 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
 234 struct 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
 241 union 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
 248 void pass_int8_ref(svint8_t &); // expected-note {{not viable}}
 249
 250 svint8_t &return_int8_ref();
 251 #if __cplusplus >= 201103L
 252 svint8_t &&return_int8_rvalue_ref();
 253 #endif
 254
 255 template <typename T>
 256 struct s_template {
 257   T y; // expected-error {{field has sizeless type '__SVInt8_t'}}
 258 };
 259
 260 template <typename T>
 261 struct 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
 268 template <typename T>
 269 struct s_array_template {
 270   T y[1]; // expected-error {{array has sizeless element type}}
 271 };
 272
 273 struct widget {
 274   widget(s_ptr_template<int>);
 275   svint8_t operator[](int);
 276 };
 277
 278 template <typename T>
 279 struct wrapper_iterator {
 280   T operator++();
 281   T operator*() const;
 282   bool operator!=(const wrapper_iterator &) const;
 283 };
 284
 285 template <typename T>
 286 struct wrapper {
 287   wrapper();
 288   operator T() const;
 289   wrapper_iterator<T> begin() const;
 290   wrapper_iterator<T> end() const;
 291 };
 292
 293 #if __cplusplus >= 201103L
 294 struct explicit_conv {
 295   explicit operator svint8_t() const; // expected-note {{explicit conversion function is not a candidate}}
 296 };
 297 #endif
 298
 299 struct constructible_from_sizeless {
 300   constructible_from_sizeless(svint8_t);
 301 };
 302
 303 void with_default(svint8_t = svint8_t());
 304
 305 #if __cplusplus >= 201103L
 306 constexpr 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 #endif
 308
 309 #if __cplusplus < 201703L
 310 void throwing_func() throw(svint8_t); // expected-error {{sizeless type 'svint8_t' (aka '__SVInt8_t') is not allowed in exception specification}}
 311 void throwing_pointer_func() throw(svint8_t *);
 312 void throwing_reference_func() throw(svint8_t &); // expected-error {{reference to sizeless type 'svint8_t' (aka '__SVInt8_t') is not allowed in exception specification}}
 313 #endif
 314
 315 template <typename T>
 316 void template_fn_direct(T) {}
 317 template <typename T>
 318 void template_fn_ref(T &) {}
 319 template <typename T>
 320 void template_fn_const_ref(const T &) {}
 321 #if __cplusplus >= 201103L
 322 template <typename T>
 323 void template_fn_rvalue_ref(T &&) {}
 324 #endif
 325
 326 #if __cplusplus >= 201103L
 327 template <typename T>
 328 using array_alias = T[1]; // expected-error {{array has sizeless element type '__SVInt8_t'}}
 329 extern array_alias<int> *array_alias_int_ptr;
 330 extern array_alias<svint8_t> *array_alias_int8_ptr; // expected-note {{in instantiation of template type alias 'array_alias' requested here}}
 331 #endif
 332
 333 extern "C" svint8_t c_return_int8();
 334
 335 void 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 >= 201103L
 348   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 #endif
 354
 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 >= 201103L
 420   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 #endif
 433
 434   template_fn_direct(local_int8);
 435   template_fn_ref(local_int8);
 436   template_fn_const_ref(local_int8);
 437 #if __cplusplus >= 201103L
 438   template_fn_rvalue_ref(local_int8);
 439 #endif
 440
 441 #if __cplusplus >= 201103L
 442   constexpr svint8_t ce_int8_a = wrapper<svint8_t>(); // expected-error {{constexpr variable cannot have non-literal type 'const svint8_t'}}
 443 #endif
 444
 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 >= 201103L
 503   _Static_assert(!__is_lvalue_reference(svint8_t &&), "");
 504 #endif
 505   _Static_assert(!__is_rvalue_reference(svint8_t), "");
 506   _Static_assert(!__is_rvalue_reference(svint8_t &), "");
 507 #if __cplusplus >= 201103L
 508   _Static_assert(__is_rvalue_reference(svint8_t &&), "");
 509 #endif
 510   _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 properties
 527   // implied by their name.
 528   _Static_assert(!__is_signed(svint8_t), "");
 529   _Static_assert(!__is_unsigned(svint8_t), "");
 530
 531 #if __cplusplus >= 201103L
 532   auto auto_int8 = local_int8;
 533   auto auto_int16 = local_int16;
 534 #if __cplusplus >= 201703L
 535   auto [auto_int8_a] = local_int8; // expected-error {{cannot decompose non-class, non-array type 'svint8_t' (aka '__SVInt8_t')}}
 536 #endif
 537 #endif
 538
 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 >= 201103L
 545   constructible_from_sizeless cfs3{local_int8};
 546 #endif
 547
 548 #if __cplusplus >= 201103L
 549   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 >= 201703L
 554   auto fn3 = [a(return_int8())] {}; // expected-error {{field has sizeless type 'svint8_t' (aka '__SVInt8_t')}}
 555 #endif
 556   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 #endif
 570 }
 571
 572 #if __cplusplus >= 201103L
 573 svint8_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
 577 void 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 #endif