clang/test/Parser/cxx1z-decomposition.cpp

   1 // RUN: %clang_cc1 -std=c++17 %s -triple x86_64-unknown-linux-gnu -verify=expected,cxx17,pre2c -fcxx-exceptions
   2 // RUN: %clang_cc1 -std=c++2b %s -triple x86_64-unknown-linux-gnu -verify=expected,cxx2b,pre2c,post2b -fcxx-exceptions
   3 // RUN: %clang_cc1 -std=c++2c %s -triple x86_64-unknown-linux-gnu -verify=expected,cxx2c,post2b -fcxx-exceptions
   4 // RUN: not %clang_cc1 -std=c++17 %s -triple x86_64-unknown-linux-gnu -emit-llvm-only -fcxx-exceptions
   5
   6 struct S { int a, b, c; };
   7
   8 // A simple-declaration can be a decompsition declaration.
   9 namespace SimpleDecl {
  10   auto [a_x, b_x, c_x] = S();
  11
  12   void f(S s) {
  13     auto [a, b, c] = S();
  14     {
  15       for (auto [a, b, c] = S();;) {}
  16       if (auto [a, b, c] = S(); true) {}
  17       switch (auto [a, b, c] = S(); 0) { case 0:; }
  18     }
  19   }
  20 }
  21
  22 // A for-range-declaration can be a decomposition declaration.
  23 namespace ForRangeDecl {
  24   extern S arr[10];
  25   void h() {
  26     for (auto [a, b, c] : arr) {
  27     }
  28   }
  29 }
  30
  31 // Other kinds of declaration cannot.
  32 namespace OtherDecl {
  33   // A parameter-declaration is not a simple-declaration.
  34   // This parses as an array declaration.
  35   void f(auto [a, b, c]); // cxx17-error {{'auto' not allowed in function prototype}} expected-error {{'a'}}
  36
  37   void g() {
  38     // A condition is allowed as a Clang extension.
  39     // See commentary in test/Parser/decomposed-condition.cpp
  40     for (; auto [a, b, c] = S(); ) {} // expected-warning {{ISO C++17 does not permit structured binding declaration in a condition}} expected-error {{value of type 'S' is not contextually convertible to 'bool'}}
  41     if (auto [a, b, c] = S()) {} // expected-warning {{ISO C++17 does not permit structured binding declaration in a condition}} expected-error {{value of type 'S' is not contextually convertible to 'bool'}}
  42     if (int n; auto [a, b, c] = S()) {} // expected-warning {{ISO C++17 does not permit structured binding declaration in a condition}} expected-error {{value of type 'S' is not contextually convertible to 'bool'}}
  43     switch (auto [a, b, c] = S()) {} // expected-warning {{ISO C++17 does not permit structured binding declaration in a condition}} expected-error {{statement requires expression of integer type ('S' invalid)}}
  44     switch (int n; auto [a, b, c] = S()) {} // expected-warning {{ISO C++17 does not permit structured binding declaration in a condition}} expected-error {{statement requires expression of integer type ('S' invalid)}}
  45     while (auto [a, b, c] = S()) {} // expected-warning {{ISO C++17 does not permit structured binding declaration in a condition}} expected-error {{value of type 'S' is not contextually convertible to 'bool'}}
  46
  47     // An exception-declaration is not a simple-declaration.
  48     try {}
  49     catch (auto [a, b, c]) {} // expected-error {{'auto' not allowed in exception declaration}} expected-error {{'a'}}
  50   }
  51
  52   // A member-declaration is not a simple-declaration.
  53   class A {
  54     auto [a, b, c] = S(); // expected-error {{not permitted in this context}}
  55     static auto [a, b, c] = S(); // expected-error {{not permitted in this context}}
  56   };
  57 }
  58
  59 namespace GoodSpecifiers {
  60   void f() {
  61     int n[1];
  62     const volatile auto &[a] = n; // post2b-warning {{volatile qualifier in structured binding declaration is deprecated}}
  63   }
  64 }
  65
  66 namespace BadSpecifiers {
  67   typedef int I1[1];
  68   I1 n;
  69   struct S { int n; } s;
  70   void f() {
  71     // storage-class-specifiers
  72     static auto &[a] = n; // cxx17-warning {{declared 'static' is a C++20 extension}}
  73     thread_local auto &[b] = n; // cxx17-warning {{declared 'thread_local' is a C++20 extension}}
  74     extern auto &[c] = n; // expected-error {{cannot be declared 'extern'}} expected-error {{declaration of block scope identifier with linkage cannot have an initializer}}
  75     struct S {
  76       mutable auto &[d] = n; // expected-error {{not permitted in this context}}
  77
  78       // function-specifiers
  79       virtual auto &[e] = n; // expected-error {{not permitted in this context}}
  80       explicit auto &[f] = n; // expected-error {{not permitted in this context}}
  81
  82       // misc decl-specifiers
  83       friend auto &[g] = n; // expected-error {{'auto' not allowed}} expected-error {{friends can only be classes or functions}}
  84     };
  85     typedef auto &[h] = n; // expected-error {{cannot be declared 'typedef'}}
  86     constexpr auto &[i] = n; // expected-error {{cannot be declared 'constexpr'}}
  87   }
  88
  89   static constexpr inline thread_local auto &[j1] = n; // expected-error {{cannot be declared with 'constexpr inline' specifiers}}
  90   static thread_local auto &[j2] = n; // cxx17-warning {{declared with 'static thread_local' specifiers is a C++20 extension}}
  91
  92   inline auto &[k] = n; // expected-error {{cannot be declared 'inline'}}
  93
  94   const int K = 5;
  95   auto ([c]) = s; // expected-error {{decomposition declaration cannot be declared with parentheses}}
  96   void g() {
  97     // defining-type-specifiers other than cv-qualifiers and 'auto'
  98     S [a] = s; // expected-error {{cannot be declared with type 'S'}}
  99     decltype(auto) [b] = s; // expected-error {{cannot be declared with type 'decltype(auto)'}}
 100     auto ([c2]) = s; // cxx17-error {{decomposition declaration cannot be declared with parenthese}} \
 101                      // post2b-error {{use of undeclared identifier 'c2'}} \
 102                      // post2b-error {{expected body of lambda expression}} \
 103
 104     // FIXME: This error is not very good.
 105     auto [d]() = s; // expected-error {{expected ';'}} expected-error {{expected expression}}
 106     auto [e][1] = s; // expected-error {{expected ';'}} expected-error {{requires an initializer}}
 107
 108     // FIXME: This should fire the 'misplaced array declarator' diagnostic.
 109     int [K] arr = {0}; // expected-error {{expected ';'}} expected-error {{cannot be declared with type 'int'}} expected-error {{decomposition declaration '[K]' requires an initializer}}
 110     int [5] arr = {0}; // expected-error {{place the brackets after the name}}
 111
 112     auto *[f] = s; // expected-error {{cannot be declared with type 'auto *'}} expected-error {{incompatible initializer}}
 113     auto S::*[g] = s; // expected-error {{cannot be declared with type 'auto BadSpecifiers::S::*'}} expected-error {{incompatible initializer}}
 114
 115     // ref-qualifiers are OK.
 116     auto &&[ok_1] = S();
 117     auto &[ok_2] = s;
 118
 119     // attributes are OK.
 120     [[]] auto [ok_3] = s;
 121     alignas(S) auto [ok_4] = s;
 122
 123     auto [bad_attr_2] [[]] = s; // expected-error {{expected ';'}} expected-error {{}}
 124   }
 125 }
 126
 127 namespace MultiDeclarator {
 128   struct S { int n; };
 129   void f(S s) {
 130     auto [a] = s, [b] = s; // expected-error {{must be the only declaration}}
 131     auto [c] = s,  d = s; // expected-error {{must be the only declaration}}
 132     auto  e  = s, [f] = s; // expected-error {{must be the only declaration}}
 133     auto g = s, h = s, i = s, [j] = s; // expected-error {{must be the only declaration}}
 134   }
 135 }
 136
 137 namespace Template {
 138   int n[3];
 139   // FIXME: There's no actual rule against this...
 140   template<typename T> auto [a, b, c] = n; // expected-error {{decomposition declaration template not supported}}
 141 }
 142
 143 namespace Init {
 144   void f() {
 145     int arr[1];
 146     struct S { int n; };
 147     auto &[bad1]; // expected-error {{decomposition declaration '[bad1]' requires an initializer}}
 148     const auto &[bad2](S{}, S{}); // expected-error {{initializer for variable '[bad2]' with type 'const auto &' contains multiple expressions}}
 149     const auto &[bad3](); // expected-error {{expected expression}}
 150     auto &[good1] = arr;
 151     auto &&[good2] = S{};
 152     const auto &[good3](S{});
 153     S [goodish3] = { 4 }; // expected-error {{cannot be declared with type 'S'}}
 154     S [goodish4] { 4 }; // expected-error {{cannot be declared with type 'S'}}
 155   }
 156 }
 157
 158
 159 namespace attributes {
 160
 161 struct S{
 162     int a;
 163     int b = 0;
 164 };
 165
 166 void err() {
 167     auto [[]] = S{0}; // expected-error {{expected unqualified-id}}
 168     auto [ alignas(42) a, foo ] = S{0}; // expected-error {{an attribute list cannot appear here}}
 169     auto [ c, [[]] d ] = S{0}; // expected-error {{an attribute list cannot appear here}}
 170     auto [ e, alignas(42) f ] = S{0}; // expected-error {{an attribute list cannot appear here}}
 171 }
 172
 173 void ok() {
 174     auto [ a alignas(42) [[]], b alignas(42) [[]]] = S{0}; // expected-error 2{{'alignas' attribute only applies to variables, data members and tag types}} \
 175                                                            // pre2c-warning  2{{an attribute specifier sequence attached to a structured binding declaration is a C++2c extension}}
 176     auto [ c [[]] alignas(42), d [[]] alignas(42) [[]]] = S{0}; // expected-error 2{{'alignas' attribute only applies to variables, data members and tag types}} \
 177                                                                 // pre2c-warning  2{{an attribute specifier sequence attached to a structured binding declaration is a C++2c extension}}
 178 }
 179
 180
 181 auto [G1 [[deprecated]], G2 [[deprecated]]] = S{42}; // #deprecated-here
 182 // pre2c-warning@-1 2{{an attribute specifier sequence attached to a structured binding declaration is a C++2c extension}}
 183
 184 int test() {
 185   return G1 + G2; // expected-warning {{'G1' is deprecated}} expected-note@#deprecated-here {{here}} \
 186                   // expected-warning {{'G2' is deprecated}} expected-note@#deprecated-here {{here}}
 187 }
 188
 189 void invalid_attributes() {
 190   // pre2c-warning@+1 {{an attribute specifier sequence attached to a structured binding declaration is a C++2c extension}}
 191   auto [a alignas(42) // expected-error {{'alignas' attribute only applies to variables, data members and tag types}}
 192       [[assume(true), // expected-error {{'assume' attribute cannot be applied to a declaration}}
 193         carries_dependency, // expected-error {{'carries_dependency' attribute only applies to parameters, Objective-C methods, and functions}}
 194         fallthrough,  // expected-error {{'fallthrough' attribute cannot be applied to a declaration}}
 195         likely, // expected-error {{'likely' attribute cannot be applied to a declaration}}
 196         unlikely, // expected-error {{'unlikely' attribute cannot be applied to a declaration}}
 197         nodiscard,  // expected-warning {{'nodiscard' attribute only applies to Objective-C methods, enums, structs, unions, classes, functions, function pointers, and typedefs}}
 198         noreturn,  // expected-error {{'noreturn' attribute only applies to functions}}
 199         no_unique_address]], // expected-error {{'no_unique_address' attribute only applies to non-bit-field non-static data members}}
 200     b] = S{0};
 201 }
 202
 203 }