1 // RUN: %clang_cc1 -fcxx-exceptions -fdeclspec -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat -Wc++14-extensions -Wc++17-extensions %s
2 
3 // Need std::initializer_list
4 namespace std {
5   typedef decltype(sizeof(int)) size_t;
6 
7   // libc++'s implementation
8   template <class _E>
9   class initializer_list
10   {
11     const _E* __begin_;
12     size_t    __size_;
13 
14     initializer_list(const _E* __b, size_t __s)
15       : __begin_(__b),
16         __size_(__s)
17     {}
18 
19   public:
20     typedef _E        value_type;
21     typedef const _E& reference;
22     typedef const _E& const_reference;
23     typedef size_t    size_type;
24 
25     typedef const _E* iterator;
26     typedef const _E* const_iterator;
27 
28     initializer_list() : __begin_(nullptr), __size_(0) {}
29 
30     size_t    size()  const {return __size_;}
31     const _E* begin() const {return __begin_;}
32     const _E* end()   const {return __begin_ + __size_;}
33   };
34 }
35 
36 
37 // Declaration syntax checks
38 [[]] int before_attr;
39 int [[]] between_attr;
40 const [[]] int between_attr_2 = 0; // expected-error {{an attribute list cannot appear here}}
41 int after_attr [[]];
42 int * [[]] ptr_attr;
43 int & [[]] ref_attr = after_attr;
44 int & [[unknown]] ref_attr_2 = after_attr; // expected-warning {{unknown attribute 'unknown' ignored}}
45 int & [[noreturn]] ref_attr_3 = after_attr; // expected-error {{'noreturn' attribute cannot be applied to types}}
46 int && [[]] rref_attr = 0;
47 int array_attr [1] [[]];
48 alignas(8) int aligned_attr;
49 [[test::valid(for 42 [very] **** '+' symbols went on a trip and had a "good"_time; the end.)]] int garbage_attr; // expected-warning {{unknown attribute 'valid' ignored}}
50 [[,,,static, class, namespace,, inline, constexpr, mutable,, bitand, bitor::compl(!.*_ Cx.!U^*R),,,]] int more_garbage_attr; // expected-warning {{unknown attribute 'static' ignored}} \
51     // expected-warning {{unknown attribute 'class' ignored}} \
52     // expected-warning {{unknown attribute 'namespace' ignored}} \
53     // expected-warning {{unknown attribute 'inline' ignored}} \
54     // expected-warning {{unknown attribute 'constexpr' ignored}} \
55     // expected-warning {{unknown attribute 'mutable' ignored}} \
56     // expected-warning {{unknown attribute 'bitand' ignored}} \
57     // expected-warning {{unknown attribute 'compl' ignored}}
58 [[u8"invalid!"]] int invalid_string_attr; // expected-error {{expected ']'}}
59 void fn_attr () [[]];
60 void noexcept_fn_attr () noexcept [[]];
61 struct MemberFnOrder {
62   virtual void f() const volatile && noexcept [[]] final = 0;
63 };
64 struct [[]] struct_attr;
65 class [[]] class_attr {};
66 union [[]] union_attr;
67 enum [[]] E { };
68 namespace test_misplacement {
69 [[]] struct struct_attr2;  //expected-error{{misplaced attributes}}
70 [[]] class class_attr2; //expected-error{{misplaced attributes}}
71 [[]] union union_attr2; //expected-error{{misplaced attributes}}
72 [[]] enum  E2 { }; //expected-error{{misplaced attributes}}
73 }
74 
75 // Checks attributes placed at wrong syntactic locations of class specifiers.
76 class [[]] [[]]
77   attr_after_class_name_decl [[]] [[]]; // expected-error {{an attribute list cannot appear here}}
78 
79 class [[]] [[]]
80  attr_after_class_name_definition [[]] [[]] [[]]{}; // expected-error {{an attribute list cannot appear here}}
81 
82 class [[]] c {};
83 class c [[]] [[]] x;
84 class c [[]] [[]] y [[]] [[]];
85 class c final [(int){0}];
86 
87 class base {};
88 class [[]] [[]] final_class
89   alignas(float) [[]] final // expected-error {{an attribute list cannot appear here}}
90   alignas(float) [[]] [[]] alignas(float): base{}; // expected-error {{an attribute list cannot appear here}}
91 
92 class [[]] [[]] final_class_another
93   [[]] [[]] alignas(16) final // expected-error {{an attribute list cannot appear here}}
94   [[]] [[]] alignas(16) [[]]{}; // expected-error {{an attribute list cannot appear here}}
95 
96 // The diagnostics here don't matter much, this just shouldn't crash:
97 class C final [[deprecated(l]] {}); // expected-error {{use of undeclared identifier}} expected-error {{expected ']'}} expected-error {{an attribute list cannot appear here}} expected-error {{expected unqualified-id}}
98 class D final alignas ([l) {}]{}); // expected-error {{expected ',' or ']' in lambda capture list}} expected-error {{an attribute list cannot appear here}}
99 
100 [[]] struct with_init_declarators {} init_declarator;
101 [[]] struct no_init_declarators; // expected-error {{misplaced attributes}}
102 template<typename> [[]] struct no_init_declarators_template; // expected-error {{an attribute list cannot appear here}}
103 void fn_with_structs() {
104   [[]] struct with_init_declarators {} init_declarator;
105   [[]] struct no_init_declarators; // expected-error {{an attribute list cannot appear here}}
106 }
107 [[]];
108 struct ctordtor {
109   [[]] ctordtor [[]] () [[]];
110   ctordtor (C) [[]];
111   [[]] ~ctordtor [[]] () [[]];
112 };
113 [[]] ctordtor::ctordtor [[]] () [[]] {}
114 [[]] ctordtor::ctordtor (C) [[]] try {} catch (...) {}
115 [[]] ctordtor::~ctordtor [[]] () [[]] {}
116 extern "C++" [[]] int extern_attr;
117 template <typename T> [[]] void template_attr ();
118 [[]] [[]] int [[]] [[]] multi_attr [[]] [[]];
119 
120 int comma_attr [[,]];
121 int scope_attr [[foo::]]; // expected-error {{expected identifier}}
122 int (paren_attr) [[]]; // expected-error {{an attribute list cannot appear here}}
123 unsigned [[]] int attr_in_decl_spec; // expected-error {{an attribute list cannot appear here}}
124 unsigned [[]] int [[]] const double_decl_spec = 0; // expected-error 2{{an attribute list cannot appear here}}
125 class foo {
126   void const_after_attr () [[]] const; // expected-error {{expected ';'}}
127 };
128 extern "C++" [[]] { } // expected-error {{an attribute list cannot appear here}}
129 [[]] template <typename T> void before_template_attr (); // expected-error {{an attribute list cannot appear here}}
130 [[]] namespace ns { int i; } // expected-error {{an attribute list cannot appear here}} expected-note {{declared here}}
131 [[]] static_assert(true, ""); //expected-error {{an attribute list cannot appear here}}
132 [[]] asm(""); // expected-error {{an attribute list cannot appear here}}
133 
134 [[]] using ns::i;
135 [[unknown]] using namespace ns; // expected-warning {{unknown attribute 'unknown' ignored}}
136 [[noreturn]] using namespace ns; // expected-error {{'noreturn' attribute only applies to functions}}
137 namespace [[]] ns2 {} // expected-warning {{attributes on a namespace declaration are a C++17 extension}}
138 
139 using[[]] alignas(4)[[]] ns::i;          // expected-error {{an attribute list cannot appear here}} expected-error {{'alignas' attribute only applies to variables, data members and tag types}} expected-warning {{ISO C++}}
140 using [[]] alignas(4) [[]] foobar = int; // expected-error {{an attribute list cannot appear here}} expected-error {{'alignas' attribute only applies to}}
141 
142 void bad_attributes_in_do_while() {
143   do {} while (
144       [[ns::i); // expected-error {{expected ']'}} \
145                 // expected-note {{to match this '['}} \
146                 // expected-error {{expected expression}}
147   do {} while (
148       [[a]b ns::i); // expected-error {{expected ']'}} \
149                     // expected-note {{to match this '['}} \
150                     // expected-error {{expected expression}}
151   do {} while (
152       [[ab]ab] ns::i); // expected-error {{an attribute list cannot appear here}}
153   do {} while ( // expected-note {{to match this '('}}
154       alignas(4 ns::i; // expected-note {{to match this '('}}
155                        // expected-error@-1 {{expected ';' after do/while}}
156 } // expected-error 2{{expected ')'}} expected-error {{expected expression}}
157 
158 [[]] using T = int; // expected-error {{an attribute list cannot appear here}}
159 using T [[]] = int; // ok
160 template<typename T> using U [[]] = T;
161 using ns::i [[]];
162 using ns::i [[]], ns::i [[]]; // expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}}
163 struct using_in_struct_base {
164   typedef int i, j, k, l;
165 };
166 struct using_in_struct : using_in_struct_base {
167   [[]] using using_in_struct_base::i;
168   using using_in_struct_base::j [[]];
169   [[]] using using_in_struct_base::k [[]], using_in_struct_base::l [[]]; // expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}}
170 };
171 using [[]] ns::i; // expected-error {{an attribute list cannot appear here}}
172 using T [[unknown]] = int; // expected-warning {{unknown attribute 'unknown' ignored}}
173 using T [[noreturn]] = int; // expected-error {{'noreturn' attribute only applies to functions}}
174 using V = int; // expected-note {{previous}}
175 using V [[gnu::vector_size(16)]] = int; // expected-error {{redefinition with different types}}
176 
177 auto trailing() -> [[]] const int; // expected-error {{an attribute list cannot appear here}}
178 auto trailing() -> const [[]] int; // expected-error {{an attribute list cannot appear here}}
179 auto trailing() -> const int [[]];
180 auto trailing_2() -> struct struct_attr [[]];
181 
182 namespace N {
183   struct S {};
184 };
185 template<typename> struct Template {};
186 
187 // FIXME: Improve this diagnostic
188 struct [[]] N::S s; // expected-error {{an attribute list cannot appear here}}
189 struct [[]] Template<int> t; // expected-error {{an attribute list cannot appear here}}
190 struct [[]] ::template Template<int> u; // expected-error {{an attribute list cannot appear here}}
191 template struct [[]] Template<char>; // expected-error {{an attribute list cannot appear here}}
192 template struct __attribute__((pure)) Template<std::size_t>; // We still allow GNU-style attributes here
193 template <> struct [[]] Template<void>;
194 
195 enum [[]] E1 {};
196 enum [[]] E2; // expected-error {{forbids forward references}}
197 enum [[]] E1;
198 enum [[]] E3 : int;
199 enum [[]] {
200   k_123 [[]] = 123 // expected-warning {{attributes on an enumerator declaration are a C++17 extension}}
201 };
202 enum [[]] E1 e; // expected-error {{an attribute list cannot appear here}}
203 enum [[]] class E4 { }; // expected-error {{an attribute list cannot appear here}}
204 enum struct [[]] E5;
205 
206 struct S {
207   friend int f [[]] (); // expected-FIXME{{an attribute list cannot appear here}}
208   friend int f1 [[noreturn]] (); //expected-error{{an attribute list cannot appear here}}
209   friend int f2 [[]] [[noreturn]] () {}
210   [[]] friend int g(); // expected-error{{an attribute list cannot appear here}}
211   [[]] friend int h() {
212   }
213   [[]] friend int f3(), f4(), f5(); // expected-error{{an attribute list cannot appear here}}
214   friend int f6 [[noreturn]] (), f7 [[noreturn]] (), f8 [[noreturn]] (); // expected-error3 {{an attribute list cannot appear here}}
215   friend class [[]] C; // expected-error{{an attribute list cannot appear here}}
216   [[]] friend class D; // expected-error{{an attribute list cannot appear here}}
217   [[]] friend int; // expected-error{{an attribute list cannot appear here}}
218 };
219 template<typename T> void tmpl(T) {}
220 template void tmpl [[]] (int); // expected-FIXME {{an attribute list cannot appear here}}
221 template [[]] void tmpl(char); // expected-error {{an attribute list cannot appear here}}
222 template void [[]] tmpl(short);
223 
224 // Argument tests
225 alignas int aligned_no_params; // expected-error {{expected '('}}
226 alignas(i) int aligned_nonconst; // expected-error {{'aligned' attribute requires integer constant}} expected-note {{read of non-const variable 'i'}}
227 
228 // Statement tests
229 void foo () {
230   [[]] ;
231   [[]] { }
232   [[]] if (0) { }
233   [[]] for (;;);
234   [[]] do {
235     [[]] continue;
236   } while (0);
237   [[]] while (0);
238 
239   [[]] switch (i) {
240     [[]] case 0:
241     [[]] default:
242       [[]] break;
243   }
244 
245   [[]] goto there;
246   [[]] there:
247 
248   [[]] try {
249   } [[]] catch (...) { // expected-error {{an attribute list cannot appear here}}
250   }
251   struct S { int arr[2]; } s;
252   (void)s.arr[ [] { return 0; }() ]; // expected-error {{C++11 only allows consecutive left square brackets when introducing an attribute}}
253   int n = __builtin_offsetof(S, arr[ [] { return 0; }() ]); // expected-error {{C++11 only allows consecutive left square brackets when introducing an attribute}}
254 
255   void bar [[noreturn]] ([[]] int i, [[]] int j);
256   using FuncType = void ([[]] int);
257   void baz([[]]...); // expected-error {{expected parameter declarator}}
258 
259   [[]] return;
260 }
261 
262 template<typename...Ts> void variadic() {
263   void bar [[noreturn...]] (); // expected-error {{attribute 'noreturn' cannot be used as an attribute pack}}
264 }
265 
266 template <int... Is> void variadic_nttp() {
267   void bar [[noreturn...]] ();                        // expected-error {{attribute 'noreturn' cannot be used as an attribute pack}}
268   void baz [[clang::no_sanitize(Is...)]] ();          // expected-error {{attribute 'no_sanitize' does not support argument pack expansion}}
269   void bor [[clang::annotate("A", "V" ...)]] ();      // expected-error {{pack expansion does not contain any unexpanded parameter packs}}
270   void bir [[clang::annotate("B", {1, 2, 3, 4})]] (); // expected-error {{'annotate' attribute requires parameter 1 to be a constant expression}} expected-note {{subexpression not valid in a constant expression}}
271   void boo [[unknown::foo(Is...)]] ();                // expected-warning {{unknown attribute 'foo' ignored}}
272   void faz [[clang::annotate("C", (Is + ...))]] ();   // expected-warning {{pack fold expression is a C++17 extension}}
273   void far [[clang::annotate("D", Is...)]] ();
274   void foz [[clang::annotate("E", 1, 2, 3, Is...)]] ();
275   void fiz [[clang::annotate("F", Is..., 1, 2, 3)]] ();
276   void fir [[clang::annotate("G", 1, Is..., 2, 3)]] ();
277 }
278 
279 // Expression tests
280 void bar () {
281   // FIXME: GCC accepts [[gnu::noreturn]] on a lambda, even though it appertains
282   // to the operator()'s type, and GCC does not otherwise accept attributes
283   // applied to types. Use that to test this.
284   [] () [[gnu::noreturn]] { return; } (); // expected-warning {{attribute 'noreturn' ignored}} FIXME-error {{should not return}}
285   [] () [[gnu::noreturn]] { throw; } (); // expected-warning {{attribute 'noreturn' ignored}}
286   new int[42][[]][5][[]]{};
287 }
288 
289 // Condition tests
290 void baz () {
291   if ([[unknown]] bool b = true) { // expected-warning {{unknown attribute 'unknown' ignored}}
292     switch ([[unknown]] int n { 42 }) { // expected-warning {{unknown attribute 'unknown' ignored}}
293     default:
294       for ([[unknown]] int n = 0; [[unknown]] char b = n < 5; ++b) { // expected-warning 2{{unknown attribute 'unknown' ignored}}
295       }
296     }
297   }
298   int x;
299   // An attribute can be applied to an expression-statement, such as the first
300   // statement in a for. But it can't be applied to a condition which is an
301   // expression.
302   for ([[]] x = 0; ; ) {} // expected-error {{an attribute list cannot appear here}}
303   for (; [[]] x < 5; ) {} // expected-error {{an attribute list cannot appear here}}
304   while ([[]] bool k { false }) {
305   }
306   while ([[]] true) { // expected-error {{an attribute list cannot appear here}}
307   }
308   do {
309   } while ([[]] false); // expected-error {{an attribute list cannot appear here}}
310 
311   for ([[unknown]] int n : { 1, 2, 3 }) { // expected-warning {{unknown attribute 'unknown' ignored}}
312   }
313 }
314 
315 enum class __attribute__((visibility("hidden"))) SecretKeepers {
316   one, /* rest are deprecated */ two, three
317 };
318 enum class [[]] EvenMoreSecrets {};
319 
320 namespace arguments {
321   void f[[gnu::format(printf, 1, 2)]](const char*, ...);
322   void g() [[unknown::foo(ignore arguments for unknown attributes, even with symbols!)]]; // expected-warning {{unknown attribute 'foo' ignored}}
323   [[deprecated("with argument")]] int i;
324   // expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}}
325 }
326 
327 // Forbid attributes on decl specifiers.
328 unsigned [[gnu::used]] static int [[gnu::unused]] v1; // expected-error {{'unused' attribute cannot be applied to types}} \
329            expected-error {{an attribute list cannot appear here}}
330 typedef [[gnu::used]] unsigned long [[gnu::unused]] v2; // expected-error {{'unused' attribute cannot be applied to types}} \
331           expected-error {{an attribute list cannot appear here}}
332 int [[carries_dependency]] foo(int [[carries_dependency]] x); // expected-error 2{{'carries_dependency' attribute cannot be applied to types}}
333 
334 // Forbid [[gnu::...]] attributes on declarator chunks.
335 int *[[gnu::unused]] v3; // expected-warning {{attribute 'unused' ignored}}
336 int v4[2][[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}}
337 int v5()[[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}}
338 
339 [[attribute_declaration]]; // expected-warning {{unknown attribute 'attribute_declaration' ignored}}
340 [[noreturn]]; // expected-error {{'noreturn' attribute only applies to functions}}
341 [[carries_dependency]]; // expected-error {{'carries_dependency' attribute only applies to parameters, Objective-C methods, and functions}}
342 
343 class A {
344   A([[gnu::unused]] int a);
345 };
346 A::A([[gnu::unused]] int a) {}
347 
348 namespace GccConst {
349   // GCC's tokenizer treats const and __const as the same token.
350   [[gnu::const]] int *f1();
351   [[gnu::__const]] int *f2();
352   [[gnu::__const__]] int *f3();
353   void f(const int *);
354   void g() { f(f1()); f(f2()); }
355   void h() { f(f3()); }
356 }
357 
358 namespace GccASan {
359   __attribute__((no_address_safety_analysis)) void f1();
360   __attribute__((no_sanitize_address)) void f2();
361   [[gnu::no_address_safety_analysis]] void f3();
362   [[gnu::no_sanitize_address]] void f4();
363 }
364 
365 namespace {
366   [[deprecated]] void bar();
367   // expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}}
368   [[deprecated("hello")]] void baz();
369   // expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}}
370   [[deprecated()]] void foo();
371   // expected-error@-1 {{parentheses must be omitted if 'deprecated' attribute's argument list is empty}}
372   [[gnu::deprecated()]] void quux();
373 }
374 
375 namespace {
376 [[ // expected-error {{expected ']'}}
377 #pragma pack(pop)
378 deprecated
379 ]] void bad();
380 }
381 
382 int fallthru(int n) {
383   switch (n) {
384   case 0:
385     n += 5;
386     [[fallthrough]]; // expected-warning {{use of the 'fallthrough' attribute is a C++17 extension}}
387   case 1:
388     n *= 2;
389     break;
390   }
391   return n;
392 }
393 
394 template<typename T> struct TemplateStruct {};
395 class FriendClassesWithAttributes {
396   // We allow GNU-style attributes here
397   template <class _Tp, class _Alloc> friend class __attribute__((__type_visibility__("default"))) vector;
398   template <class _Tp, class _Alloc> friend class __declspec(code_seg("foo,whatever")) vector2;
399   // But not C++11 ones
400   template <class _Tp, class _Alloc> friend class[[]] vector3;                                         // expected-error {{an attribute list cannot appear here}}
401   template <class _Tp, class _Alloc> friend class [[clang::__type_visibility__(("default"))]] vector4; // expected-error {{an attribute list cannot appear here}}
402 
403   // Also allowed
404   friend struct __attribute__((__type_visibility__("default"))) TemplateStruct<FriendClassesWithAttributes>;
405   friend struct __declspec(code_seg("foo,whatever")) TemplateStruct<FriendClassesWithAttributes>;
406   friend struct[[]] TemplateStruct<FriendClassesWithAttributes>;                                       // expected-error {{an attribute list cannot appear here}}
407   friend struct [[clang::__type_visibility__("default")]] TemplateStruct<FriendClassesWithAttributes>; // expected-error {{an attribute list cannot appear here}}
408 };
409 
410 #define attr_name bitand
411 #define attr_name_2(x) x
412 #define attr_name_3(x, y) x##y
413 [[attr_name, attr_name_2(bitor), attr_name_3(com, pl)]] int macro_attrs; // expected-warning {{unknown attribute 'compl' ignored}} \
414    expected-warning {{unknown attribute 'bitor' ignored}} \
415    expected-warning {{unknown attribute 'bitand' ignored}}
416 
417 // Check that we can parse an attribute in our vendor namespace.
418 [[clang::annotate("test")]] void annotate1();
419 [[_Clang::annotate("test")]] void annotate2();
420 // Note: __clang__ is a predefined macro, which is why _Clang is the
421 // prefered "protected" vendor namespace. We support __clang__ only for
422 // people expecting it to behave the same as __gnu__.
423 [[__clang__::annotate("test")]] void annotate3();  // expected-warning {{'__clang__' is a predefined macro name, not an attribute scope specifier; did you mean '_Clang' instead?}}
424