Clang Project

clang_source_code/test/Parser/cxx0x-attributes.cpp
1// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat -Wc++14-extensions -Wc++17-extensions %s
2
3// Need std::initializer_list
4namespace 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;
39int [[]] between_attr;
40const [[]] int between_attr_2 = 0; // expected-error {{an attribute list cannot appear here}}
41int after_attr [[]];
42int * [[]] ptr_attr;
43int & [[]] ref_attr = after_attr;
44int & [[unknown]] ref_attr_2 = after_attr; // expected-warning {{unknown attribute 'unknown' ignored}}
45int & [[noreturn]] ref_attr_3 = after_attr; // expected-error {{'noreturn' attribute cannot be applied to types}}
46int && [[]] rref_attr = 0;
47int array_attr [1] [[]];
48alignas(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 ']'}}
59void fn_attr () [[]];
60void noexcept_fn_attr () noexcept [[]];
61struct MemberFnOrder {
62  virtual void f() const volatile && noexcept [[]] final = 0;
63};
64struct [[]] struct_attr;
65class [[]] class_attr {};
66union [[]] union_attr;
67enum [[]] E { };
68namespace 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.
76class [[]] [[]]
77  attr_after_class_name_decl [[]] [[]]; // expected-error {{an attribute list cannot appear here}}
78
79class [[]] [[]]
80 attr_after_class_name_definition [[]] [[]] [[]]{}; // expected-error {{an attribute list cannot appear here}}
81
82class [[]] c {};
83class c [[]] [[]] x;
84class c [[]] [[]] y [[]] [[]];
85class c final [(int){0}];
86
87class base {};
88class [[]] [[]] 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
92class [[]] [[]] 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:
97class 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}}
98class 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}}
102template<typename> [[]] struct no_init_declarators_template; // expected-error {{an attribute list cannot appear here}}
103void 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[[]];
108struct ctordtor {
109  [[]] ctordtor [[]] () [[]];
110  ctordtor (C) [[]];
111  [[]] ~ctordtor [[]] () [[]];
112};
113[[]] ctordtor::ctordtor [[]] () [[]] {}
114[[]] ctordtor::ctordtor (C) [[]] try {} catch (...) {}
115[[]] ctordtor::~ctordtor [[]] () [[]] {}
116extern "C++" [[]] int extern_attr;
117template <typename T> [[]] void template_attr ();
118[[]] [[]] int [[]] [[]] multi_attr [[]] [[]];
119
120int comma_attr [[,]];
121int scope_attr [[foo::]]; // expected-error {{expected identifier}}
122int (paren_attr) [[]]; // expected-error {{an attribute list cannot appear here}}
123unsigned [[]] int attr_in_decl_spec; // expected-error {{an attribute list cannot appear here}}
124unsigned [[]] int [[]] const double_decl_spec = 0; // expected-error 2{{an attribute list cannot appear here}}
125class foo {
126  void const_after_attr () [[]] const; // expected-error {{expected ';'}}
127};
128extern "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; // expected-error {{an attribute list cannot appear here}}
135[[unknown]] using namespace ns; // expected-warning {{unknown attribute 'unknown' ignored}}
136[[noreturn]] using namespace ns; // expected-error {{'noreturn' attribute only applies to functions}}
137namespace [[]] ns2 {} // expected-warning {{attributes on a namespace declaration are a C++17 extension}}
138
139using [[]] alignas(4) [[]] ns::i; // expected-error {{an attribute list cannot appear here}}
140using [[]] alignas(4) [[]] foobar = int; // expected-error {{an attribute list cannot appear here}} expected-error {{'alignas' attribute only applies to}}
141
142void 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 2{{expected ')'}} expected-error {{expected expression}}
156
157[[]] using T = int; // expected-error {{an attribute list cannot appear here}}
158using T [[]] = int; // ok
159template<typename T> using U [[]] = T;
160using ns::i [[]]; // expected-error {{an attribute list cannot appear here}}
161using [[]] ns::i; // expected-error {{an attribute list cannot appear here}}
162using T [[unknown]] = int; // expected-warning {{unknown attribute 'unknown' ignored}}
163using T [[noreturn]] = int; // expected-error {{'noreturn' attribute only applies to functions}}
164using V = int; // expected-note {{previous}}
165using V [[gnu::vector_size(16)]] = int; // expected-error {{redefinition with different types}}
166
167auto trailing() -> [[]] const int; // expected-error {{an attribute list cannot appear here}}
168auto trailing() -> const [[]] int; // expected-error {{an attribute list cannot appear here}}
169auto trailing() -> const int [[]];
170auto trailing_2() -> struct struct_attr [[]];
171
172namespace N {
173  struct S {};
174};
175template<typename> struct Template {};
176
177// FIXME: Improve this diagnostic
178struct [[]] N::S s; // expected-error {{an attribute list cannot appear here}}
179struct [[]] Template<int> t; // expected-error {{an attribute list cannot appear here}}
180struct [[]] ::template Template<int> u; // expected-error {{an attribute list cannot appear here}}
181template struct [[]] Template<char>; // expected-error {{an attribute list cannot appear here}}
182template <> struct [[]] Template<void>;
183
184enum [[]] E1 {};
185enum [[]] E2; // expected-error {{forbids forward references}}
186enum [[]] E1;
187enum [[]] E3 : int;
188enum [[]] {
189  k_123 [[]] = 123 // expected-warning {{attributes on an enumerator declaration are a C++17 extension}}
190};
191enum [[]] E1 e; // expected-error {{an attribute list cannot appear here}}
192enum [[]] class E4 { }; // expected-error {{an attribute list cannot appear here}}
193enum struct [[]] E5;
194
195struct S {
196  friend int f [[]] (); // expected-FIXME{{an attribute list cannot appear here}}
197  friend int f1 [[noreturn]] (); //expected-error{{an attribute list cannot appear here}}
198  friend int f2 [[]] [[noreturn]] () {}
199  [[]] friend int g(); // expected-error{{an attribute list cannot appear here}}
200  [[]] friend int h() {
201  }
202  [[]] friend int f3(), f4(), f5(); // expected-error{{an attribute list cannot appear here}}
203  friend int f6 [[noreturn]] (), f7 [[noreturn]] (), f8 [[noreturn]] (); // expected-error3 {{an attribute list cannot appear here}}
204  friend class [[]] C; // expected-error{{an attribute list cannot appear here}}
205  [[]] friend class D; // expected-error{{an attribute list cannot appear here}}
206  [[]] friend int; // expected-error{{an attribute list cannot appear here}}
207};
208template<typename T> void tmpl(T) {}
209template void tmpl [[]] (int); // expected-FIXME {{an attribute list cannot appear here}}
210template [[]] void tmpl(char); // expected-error {{an attribute list cannot appear here}}
211template void [[]] tmpl(short);
212
213// Argument tests
214alignas int aligned_no_params; // expected-error {{expected '('}}
215alignas(i) int aligned_nonconst; // expected-error {{'aligned' attribute requires integer constant}} expected-note {{read of non-const variable 'i'}}
216
217// Statement tests
218void foo () {
219  [[]] ;
220  [[]] { }
221  [[]] if (0) { }
222  [[]] for (;;);
223  [[]] do {
224    [[]] continue;
225  } while (0);
226  [[]] while (0);
227
228  [[]] switch (i) {
229    [[]] case 0:
230    [[]] default:
231      [[]] break;
232  }
233
234  [[]] goto there;
235  [[]] there:
236
237  [[]] try {
238  } [[]] catch (...) { // expected-error {{an attribute list cannot appear here}}
239  }
240  struct S { int arr[2]; } s;
241  (void)s.arr[ [] { return 0; }() ]; // expected-error {{C++11 only allows consecutive left square brackets when introducing an attribute}}
242  int n = __builtin_offsetof(S, arr[ [] { return 0; }() ]); // expected-error {{C++11 only allows consecutive left square brackets when introducing an attribute}}
243
244  void bar [[noreturn]] ([[]] int i, [[]] int j);
245  using FuncType = void ([[]] int);
246  void baz([[]]...); // expected-error {{expected parameter declarator}}
247
248  [[]] return;
249}
250
251template<typename...Ts> void variadic() {
252  void bar [[noreturn...]] (); // expected-error {{attribute 'noreturn' cannot be used as an attribute pack}}
253}
254
255// Expression tests
256void bar () {
257  // FIXME: GCC accepts [[gnu::noreturn]] on a lambda, even though it appertains
258  // to the operator()'s type, and GCC does not otherwise accept attributes
259  // applied to types. Use that to test this.
260  [] () [[gnu::noreturn]] { return; } (); // expected-warning {{attribute 'noreturn' ignored}} FIXME-error {{should not return}}
261  [] () [[gnu::noreturn]] { throw; } (); // expected-warning {{attribute 'noreturn' ignored}}
262  new int[42][[]][5][[]]{};
263}
264
265// Condition tests
266void baz () {
267  if ([[unknown]] bool b = true) { // expected-warning {{unknown attribute 'unknown' ignored}}
268    switch ([[unknown]] int n { 42 }) { // expected-warning {{unknown attribute 'unknown' ignored}}
269    default:
270      for ([[unknown]] int n = 0; [[unknown]] char b = n < 5; ++b) { // expected-warning 2{{unknown attribute 'unknown' ignored}}
271      }
272    }
273  }
274  int x;
275  // An attribute can be applied to an expression-statement, such as the first
276  // statement in a for. But it can't be applied to a condition which is an
277  // expression.
278  for ([[]] x = 0; ; ) {} // expected-error {{an attribute list cannot appear here}}
279  for (; [[]] x < 5; ) {} // expected-error {{an attribute list cannot appear here}}
280  while ([[]] bool k { false }) {
281  }
282  while ([[]] true) { // expected-error {{an attribute list cannot appear here}}
283  }
284  do {
285  } while ([[]] false); // expected-error {{an attribute list cannot appear here}}
286
287  for ([[unknown]] int n : { 1, 2, 3 }) { // expected-warning {{unknown attribute 'unknown' ignored}}
288  }
289}
290
291enum class __attribute__((visibility("hidden"))) SecretKeepers {
292  one, /* rest are deprecated */ two, three
293};
294enum class [[]] EvenMoreSecrets {};
295
296namespace arguments {
297  void f[[gnu::format(printf, 1, 2)]](const char*, ...);
298  void g() [[unknown::foo(ignore arguments for unknown attributes, even with symbols!)]]; // expected-warning {{unknown attribute 'foo' ignored}}
299  [[deprecated("with argument")]] int i;
300  // expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}}
301}
302
303// Forbid attributes on decl specifiers.
304unsigned [[gnu::used]] static int [[gnu::unused]] v1; // expected-error {{'unused' attribute cannot be applied to types}} \
305           expected-error {{an attribute list cannot appear here}}
306typedef [[gnu::used]] unsigned long [[gnu::unused]] v2; // expected-error {{'unused' attribute cannot be applied to types}} \
307          expected-error {{an attribute list cannot appear here}}
308int [[carries_dependency]] foo(int [[carries_dependency]] x); // expected-error 2{{'carries_dependency' attribute cannot be applied to types}}
309
310// Forbid [[gnu::...]] attributes on declarator chunks.
311int *[[gnu::unused]] v3; // expected-warning {{attribute 'unused' ignored}}
312int v4[2][[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}}
313int v5()[[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}}
314
315[[attribute_declaration]]; // expected-warning {{unknown attribute 'attribute_declaration' ignored}}
316[[noreturn]]; // expected-error {{'noreturn' attribute only applies to functions}}
317[[carries_dependency]]; // expected-error {{'carries_dependency' attribute only applies to parameters, Objective-C methods, and functions}}
318
319class A {
320  A([[gnu::unused]] int a);
321};
322A::A([[gnu::unused]] int a) {}
323
324namespace GccConst {
325  // GCC's tokenizer treats const and __const as the same token.
326  [[gnu::const]] int *f1();
327  [[gnu::__const]] int *f2();
328  [[gnu::__const__]] int *f3();
329  void f(const int *);
330  void g() { f(f1()); f(f2()); }
331  void h() { f(f3()); }
332}
333
334namespace GccASan {
335  __attribute__((no_address_safety_analysis)) void f1();
336  __attribute__((no_sanitize_address)) void f2();
337  [[gnu::no_address_safety_analysis]] void f3();
338  [[gnu::no_sanitize_address]] void f4();
339}
340
341namespace {
342  [[deprecated]] void bar();
343  // expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}}
344  [[deprecated("hello")]] void baz();
345  // expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}}
346  [[deprecated()]] void foo();
347  // expected-error@-1 {{parentheses must be omitted if 'deprecated' attribute's argument list is empty}}
348  [[gnu::deprecated()]] void quux();
349}
350
351namespace {
352[[ // expected-error {{expected ']'}}
353#pragma pack(pop)
354deprecated
355]] void bad();
356}
357
358int fallthru(int n) {
359  switch (n) {
360  case 0:
361    n += 5;
362    [[fallthrough]]; // expected-warning {{use of the 'fallthrough' attribute is a C++17 extension}}
363  case 1:
364    n *= 2;
365    break;
366  }
367  return n;
368}
369
370#define attr_name bitand
371#define attr_name_2(x) x
372#define attr_name_3(x, y) x##y
373[[attr_name, attr_name_2(bitor), attr_name_3(com, pl)]] int macro_attrs; // expected-warning {{unknown attribute 'compl' ignored}} \
374   expected-warning {{unknown attribute 'bitor' ignored}} \
375   expected-warning {{unknown attribute 'bitand' ignored}}
376
377// Check that we can parse an attribute in our vendor namespace.
378[[clang::annotate("test")]] void annotate1();
379[[_Clang::annotate("test")]] void annotate2();
380// Note: __clang__ is a predefined macro, which is why _Clang is the
381// prefered "protected" vendor namespace. We support __clang__ only for
382// people expecting it to behave the same as __gnu__.
383[[__clang__::annotate("test")]] void annotate3();  // expected-warning {{'__clang__' is a predefined macro name, not an attribute scope specifier; did you mean '_Clang' instead?}}
384
CodeThinker, Enjoy your reading code