clang/test/Parser/cxx0x-keyword-attributes.cpp

   1 // RUN: sed -e "s@ATTR_USE@__arm_streaming@g" -e "s@ATTR_NAME@__arm_streaming@g" %s > %t
   2 // RUN: %clang_cc1 -fcxx-exceptions -fdeclspec -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat -Wc++14-extensions -Wc++17-extensions -triple aarch64-none-linux-gnu -target-feature +sme -x c++ %t
   3 // RUN: sed -e "s@ATTR_USE@__arm_inout\(\"za\"\)@g" -e "s@ATTR_NAME@__arm_inout@g" %s > %t
   4 // RUN: %clang_cc1 -fcxx-exceptions -fdeclspec -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat -Wc++14-extensions -Wc++17-extensions -triple aarch64-none-linux-gnu -target-feature +sme -x c++ %t
   5
   6 // Need std::initializer_list
   7 namespace std {
   8   typedef decltype(sizeof(int)) size_t;
   9
  10   // libc++'s implementation
  11   template <class _E>
  12   class initializer_list
  13   {
  14     const _E* __begin_;
  15     size_t    __size_;
  16
  17     initializer_list(const _E* __b, size_t __s)
  18       : __begin_(__b),
  19         __size_(__s)
  20     {}
  21
  22   public:
  23     typedef _E        value_type;
  24     typedef const _E& reference;
  25     typedef const _E& const_reference;
  26     typedef size_t    size_type;
  27
  28     typedef const _E* iterator;
  29     typedef const _E* const_iterator;
  30
  31     initializer_list() : __begin_(nullptr), __size_(0) {}
  32
  33     size_t    size()  const {return __size_;}
  34     const _E* begin() const {return __begin_;}
  35     const _E* end()   const {return __begin_ + __size_;}
  36   };
  37 }
  38
  39
  40 // Declaration syntax checks
  41 ATTR_USE int before_attr; // expected-error {{'ATTR_NAME' only applies to function types}}
  42 int ATTR_USE between_attr; // expected-error {{'ATTR_NAME' only applies to function types}}
  43 const ATTR_USE int between_attr_2 = 0; // expected-error {{'ATTR_NAME' cannot appear here}}
  44 int after_attr ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
  45 int * ATTR_USE ptr_attr; // expected-error {{'ATTR_NAME' only applies to function types}}
  46 int & ATTR_USE ref_attr = after_attr; // expected-error {{'ATTR_NAME' only applies to function types}}
  47 int && ATTR_USE rref_attr = 0; // expected-error {{'ATTR_NAME' only applies to function types}}
  48 int array_attr [1] ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
  49 void fn_attr () ATTR_USE;
  50 void noexcept_fn_attr () noexcept ATTR_USE;
  51 struct MemberFnOrder {
  52   virtual void f() const volatile && noexcept ATTR_USE final = 0;
  53 };
  54 struct ATTR_USE struct_attr; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
  55 class ATTR_USE class_attr {}; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
  56 union ATTR_USE union_attr; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
  57 enum ATTR_USE E { }; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
  58 namespace test_misplacement {
  59 ATTR_USE struct struct_attr2;  // expected-error {{misplaced 'ATTR_NAME'}}
  60 ATTR_USE class class_attr2; // expected-error {{misplaced 'ATTR_NAME'}}
  61 ATTR_USE union union_attr2; // expected-error {{misplaced 'ATTR_NAME'}}
  62 ATTR_USE enum  E2 { }; // expected-error {{misplaced 'ATTR_NAME'}}
  63 }
  64
  65 // Checks attributes placed at wrong syntactic locations of class specifiers.
  66 class ATTR_USE ATTR_USE // expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
  67   attr_after_class_name_decl ATTR_USE ATTR_USE; // expected-error {{'ATTR_NAME' cannot appear here}} \
  68                                                                  expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
  69
  70 class ATTR_USE ATTR_USE // expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
  71  attr_after_class_name_definition ATTR_USE ATTR_USE ATTR_USE{}; // expected-error {{'ATTR_NAME' cannot appear here}} \
  72                                                                                         expected-error 3 {{'ATTR_NAME' only applies to non-K&R-style functions}}
  73
  74 class ATTR_USE c {}; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
  75 class c ATTR_USE ATTR_USE x; // expected-error 2 {{'ATTR_NAME' only applies to function types}}
  76 class c ATTR_USE ATTR_USE y ATTR_USE ATTR_USE; // expected-error 4 {{'ATTR_NAME' only applies to function types}}
  77 class c final [(int){0}];
  78
  79 class base {};
  80 class ATTR_USE ATTR_USE final_class // expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
  81   ATTR_USE alignas(float) final // expected-error {{'ATTR_NAME' cannot appear here}} \
  82                                           expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
  83   ATTR_USE alignas(float) ATTR_USE alignas(float): base{}; // expected-error {{'ATTR_NAME' cannot appear here}}
  84
  85 class ATTR_USE ATTR_USE final_class_another // expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
  86   ATTR_USE ATTR_USE alignas(16) final // expected-error {{'ATTR_NAME' cannot appear here}} \
  87                                                        expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
  88   ATTR_USE ATTR_USE alignas(16) ATTR_USE{}; // expected-error {{'ATTR_NAME' cannot appear here}}
  89
  90 class after_class_close {} ATTR_USE; // expected-error {{'ATTR_NAME' cannot appear here, place it after "class" to apply it to the type declaration}}
  91
  92 class C {};
  93
  94 ATTR_USE struct with_init_declarators {} init_declarator; // expected-error {{'ATTR_NAME' only applies to function types}}
  95 ATTR_USE struct no_init_declarators; // expected-error {{misplaced 'ATTR_NAME'}}
  96 template<typename> ATTR_USE struct no_init_declarators_template; // expected-error {{'ATTR_NAME' cannot appear here}}
  97 void fn_with_structs() {
  98   ATTR_USE struct with_init_declarators {} init_declarator; // expected-error {{'ATTR_NAME' only applies to function types}}
  99   ATTR_USE struct no_init_declarators; // expected-error {{'ATTR_NAME' cannot appear here}}
 100 }
 101 ATTR_USE; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 102 struct ctordtor {
 103   ATTR_USE ctordtor ATTR_USE () ATTR_USE; // expected-error 2 {{'ATTR_NAME' cannot be applied to a declaration}}
 104   ctordtor (C) ATTR_USE;
 105   ATTR_USE ~ctordtor ATTR_USE () ATTR_USE; // expected-error 2 {{'ATTR_NAME' cannot be applied to a declaration}}
 106 };
 107 ATTR_USE ctordtor::ctordtor ATTR_USE () ATTR_USE {} // expected-error 2 {{'ATTR_NAME' cannot be applied to a declaration}}
 108 ATTR_USE ctordtor::ctordtor (C) ATTR_USE try {} catch (...) {} // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
 109 ATTR_USE ctordtor::~ctordtor ATTR_USE () ATTR_USE {} // expected-error 2 {{'ATTR_NAME' cannot be applied to a declaration}}
 110 extern "C++" ATTR_USE int extern_attr; // expected-error {{'ATTR_NAME' only applies to function types}}
 111 template <typename T> ATTR_USE void template_attr (); // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
 112 ATTR_USE ATTR_USE int ATTR_USE ATTR_USE multi_attr ATTR_USE ATTR_USE; // expected-error 6 {{'ATTR_NAME' only applies to function types}}
 113
 114 int (paren_attr) ATTR_USE; // expected-error {{'ATTR_NAME' cannot appear here}}
 115 unsigned ATTR_USE int attr_in_decl_spec; // expected-error {{'ATTR_NAME' cannot appear here}}
 116 unsigned ATTR_USE int ATTR_USE const double_decl_spec = 0; // expected-error 2 {{'ATTR_NAME' cannot appear here}}
 117 class foo {
 118   void const_after_attr () ATTR_USE const; // expected-error {{expected ';'}}
 119 };
 120 extern "C++" ATTR_USE { } // expected-error {{'ATTR_NAME' cannot appear here}}
 121 ATTR_USE extern "C++" { } // expected-error {{'ATTR_NAME' cannot appear here}}
 122 ATTR_USE template <typename T> void before_template_attr (); // expected-error {{'ATTR_NAME' cannot appear here}}
 123 ATTR_USE namespace ns { int i; } // expected-error {{'ATTR_NAME' cannot appear here}}
 124 ATTR_USE static_assert(true, ""); //expected-error {{'ATTR_NAME' cannot appear here}}
 125 ATTR_USE asm(""); // expected-error {{'ATTR_NAME' cannot appear here}}
 126
 127 ATTR_USE using ns::i; // expected-warning {{ISO C++}} \
 128                                 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 129 ATTR_USE using namespace ns; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 130 namespace ATTR_USE ns2 {} // expected-warning {{attributes on a namespace declaration are a C++17 extension}} \
 131                                     expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 132
 133 using ATTR_USE alignas(4)ATTR_USE ns::i;          // expected-warning 2 {{ISO C++}} \
 134                                                                    expected-error {{'ATTR_NAME' cannot appear here}} \
 135                                                                    expected-error {{'alignas' attribute only applies to variables, data members and tag types}} \
 136                                                                    expected-warning {{ISO C++}} \
 137                                                                    expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
 138 using ATTR_USE alignas(4) ATTR_USE foobar = int; // expected-error {{'ATTR_NAME' cannot appear here}} \
 139                                                                   expected-error {{'alignas' attribute only applies to}} \
 140                                                                   expected-error 2 {{'ATTR_NAME' only applies to function types}}
 141
 142 ATTR_USE using T = int; // expected-error {{'ATTR_NAME' cannot appear here}}
 143 using T ATTR_USE = int; // expected-error {{'ATTR_NAME' only applies to function types}}
 144 template<typename T> using U ATTR_USE = T; // expected-error {{'ATTR_NAME' only applies to function types}}
 145 using ns::i ATTR_USE; // expected-warning {{ISO C++}} \
 146                                 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 147 using ns::i ATTR_USE, ns::i ATTR_USE; // expected-warning 2 {{ISO C++}} \
 148                                                        expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}} \
 149                                                        expected-error 2 {{'ATTR_NAME' only applies to non-K&R-style functions}}
 150 struct using_in_struct_base {
 151   typedef int i, j, k, l;
 152 };
 153 struct using_in_struct : using_in_struct_base {
 154   ATTR_USE using using_in_struct_base::i; // expected-warning {{ISO C++}} \
 155                                                     expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 156   using using_in_struct_base::j ATTR_USE; // expected-warning {{ISO C++}} \
 157                                                     expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 158   ATTR_USE using using_in_struct_base::k ATTR_USE, using_in_struct_base::l ATTR_USE; // expected-warning 3 {{ISO C++}} \
 159                                                                                                              expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}} \
 160                                                                                                              expected-error 4 {{'ATTR_NAME' only applies to non-K&R-style functions}}
 161 };
 162 using ATTR_USE ns::i; // expected-warning {{ISO C++}} \
 163                                 expected-error {{'ATTR_NAME' cannot appear here}} \
 164                                 expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 165 using T ATTR_USE = int; // expected-error {{'ATTR_NAME' only applies to function types}}
 166
 167 auto trailing() -> ATTR_USE const int; // expected-error {{'ATTR_NAME' cannot appear here}}
 168 auto trailing() -> const ATTR_USE int; // expected-error {{'ATTR_NAME' cannot appear here}}
 169 auto trailing() -> const int ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
 170 auto trailing_2() -> struct struct_attr ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
 171
 172 namespace N {
 173   struct S {};
 174 };
 175 template<typename> struct Template {};
 176
 177 // FIXME: Improve this diagnostic
 178 struct ATTR_USE N::S s; // expected-error {{'ATTR_NAME' cannot appear here}}
 179 struct ATTR_USE Template<int> t; // expected-error {{'ATTR_NAME' cannot appear here}}
 180 struct ATTR_USE ::template Template<int> u; // expected-error {{'ATTR_NAME' cannot appear here}}
 181 template struct ATTR_USE Template<char>; // expected-error {{'ATTR_NAME' cannot appear here}}
 182 template struct __attribute__((pure)) Template<std::size_t>; // We still allow GNU-style attributes here
 183 template <> struct ATTR_USE Template<void>; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 184
 185 enum ATTR_USE E1 {}; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 186 enum ATTR_USE E2; // expected-error {{forbids forward references}} \
 187                             expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 188 enum ATTR_USE E1; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 189 enum ATTR_USE E3 : int; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 190 enum ATTR_USE { // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 191   k_123 ATTR_USE = 123 // expected-warning {{attributes on an enumerator declaration are a C++17 extension}} \
 192                                  expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 193 };
 194 enum ATTR_USE E1 e; // expected-error {{'ATTR_NAME' cannot appear here}}
 195 enum ATTR_USE class E4 { }; // expected-error {{'ATTR_NAME' cannot appear here}}
 196 enum struct ATTR_USE E5; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 197 enum E6 {} ATTR_USE; // expected-error {{'ATTR_NAME' cannot appear here, place it after "enum" to apply it to the type declaration}}
 198
 199 struct S {
 200   friend int f ATTR_USE (); // expected-error {{'ATTR_NAME' cannot appear here}} \
 201                                       expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
 202   friend int f2 ATTR_USE () {} // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
 203   ATTR_USE friend int g(); // expected-error {{'ATTR_NAME' cannot appear here}}
 204   ATTR_USE friend int h() { // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
 205   }
 206   ATTR_USE friend int f3(), f4(), f5(); // expected-error {{'ATTR_NAME' cannot appear here}}
 207   friend int f6 ATTR_USE (), f7 ATTR_USE (), f8 ATTR_USE (); // expected-error3 {{'ATTR_NAME' cannot appear here}} \
 208                                                                                      expected-error 3 {{'ATTR_NAME' cannot be applied to a declaration}}
 209   friend class ATTR_USE C; // expected-error {{'ATTR_NAME' cannot appear here}}
 210   ATTR_USE friend class D; // expected-error {{'ATTR_NAME' cannot appear here}}
 211   ATTR_USE friend int; // expected-error {{'ATTR_NAME' cannot appear here}}
 212 };
 213 template<typename T> void tmpl (T) {}
 214 template ATTR_USE void tmpl(char); // expected-error {{'ATTR_NAME' cannot appear here}}
 215 template void ATTR_USE tmpl(short); // expected-error {{'ATTR_NAME' only applies to function types}}
 216
 217 // Statement tests
 218 void foo () {
 219   ATTR_USE ; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 220   ATTR_USE { } // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 221   ATTR_USE if (0) { } // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 222   ATTR_USE for (;;); // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 223   ATTR_USE do { // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 224     ATTR_USE continue; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 225   } while (0);
 226   ATTR_USE while (0); // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 227
 228   ATTR_USE switch (i) { // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 229     ATTR_USE case 0: // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 230     ATTR_USE default: // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 231       ATTR_USE break; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 232   }
 233
 234   ATTR_USE goto there; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 235   ATTR_USE there: // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 236
 237   ATTR_USE try { // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 238   } ATTR_USE catch (...) { // expected-error {{'ATTR_NAME' cannot appear here}}
 239   }
 240
 241   void bar ATTR_USE (ATTR_USE int i, ATTR_USE int j); // expected-error 2 {{'ATTR_NAME' only applies to function types}} \
 242                                                                               expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
 243   using FuncType = void (ATTR_USE int); // expected-error {{'ATTR_NAME' only applies to function types}}
 244   void baz(ATTR_USE...); // expected-error {{expected parameter declarator}}
 245
 246   ATTR_USE return; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 247 }
 248
 249 // Expression tests
 250 void bar () {
 251   new int[42]ATTR_USE[5]ATTR_USE{}; // expected-error {{'ATTR_NAME' only applies to function types}}
 252 }
 253
 254 // Condition tests
 255 void baz () {
 256   if (ATTR_USE bool b = true) { // expected-error {{'ATTR_NAME' only applies to function types}}
 257     switch (ATTR_USE int n { 42 }) { // expected-error {{'ATTR_NAME' only applies to function types}}
 258     default:
 259       for (ATTR_USE int n = 0; ATTR_USE char b = n < 5; ++b) { // expected-error 2 {{'ATTR_NAME' only applies to function types}}
 260       }
 261     }
 262   }
 263   int x;
 264   // An attribute can be applied to an expression-statement, such as the first
 265   // statement in a for. But it can't be applied to a condition which is an
 266   // expression.
 267   for (ATTR_USE x = 0; ; ) {} // expected-error {{'ATTR_NAME' cannot appear here}}
 268   for (; ATTR_USE x < 5; ) {} // expected-error {{'ATTR_NAME' cannot appear here}}
 269   while (ATTR_USE bool k { false }) { // expected-error {{'ATTR_NAME' only applies to function types}}
 270   }
 271   while (ATTR_USE true) { // expected-error {{'ATTR_NAME' cannot appear here}}
 272   }
 273   do {
 274   } while (ATTR_USE false); // expected-error {{'ATTR_NAME' cannot appear here}}
 275
 276   for (ATTR_USE int n : { 1, 2, 3 }) { // expected-error {{'ATTR_NAME' only applies to function types}}
 277   }
 278 }
 279
 280 enum class __attribute__((visibility("hidden"))) SecretKeepers {
 281   one, /* rest are deprecated */ two, three
 282 };
 283 enum class ATTR_USE EvenMoreSecrets {}; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 284
 285 // Forbid attributes on decl specifiers.
 286 unsigned ATTR_USE static int ATTR_USE v1; // expected-error {{'ATTR_NAME' only applies to function types}} \
 287            expected-error {{'ATTR_NAME' cannot appear here}}
 288 typedef ATTR_USE unsigned long ATTR_USE v2; // expected-error {{'ATTR_NAME' only applies to function types}} \
 289           expected-error {{'ATTR_NAME' cannot appear here}}
 290 int ATTR_USE foo(int ATTR_USE x); // expected-error 2 {{'ATTR_NAME' only applies to function types}}
 291
 292 ATTR_USE; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 293
 294 class A {
 295   A(ATTR_USE int a); // expected-error {{'ATTR_NAME' only applies to function types}}
 296 };
 297 A::A(ATTR_USE int a) {} // expected-error {{'ATTR_NAME' only applies to function types}}
 298
 299 template<typename T> struct TemplateStruct {};
 300 class FriendClassesWithAttributes {
 301   // We allow GNU-style attributes here
 302   template <class _Tp, class _Alloc> friend class __attribute__((__type_visibility__("default"))) vector;
 303   template <class _Tp, class _Alloc> friend class __declspec(code_seg("foo,whatever")) vector2;
 304   // But not C++11 ones
 305   template <class _Tp, class _Alloc> friend class ATTR_USE vector3;                                         // expected-error {{'ATTR_NAME' cannot appear here}}
 306
 307   // Also allowed
 308   friend struct __attribute__((__type_visibility__("default"))) TemplateStruct<FriendClassesWithAttributes>;
 309   friend struct __declspec(code_seg("foo,whatever")) TemplateStruct<FriendClassesWithAttributes>;
 310   friend struct ATTR_USE TemplateStruct<FriendClassesWithAttributes>;                                       // expected-error {{'ATTR_NAME' cannot appear here}}
 311 };
 312
 313 // Check ordering: C++11 attributes must appear before GNU attributes.
 314 class Ordering {
 315   void f1(
 316     int (ATTR_USE __attribute__(()) int n) // expected-error {{'ATTR_NAME' only applies to function types}}
 317   ) {
 318   }
 319
 320   void f2(
 321       int (*)(ATTR_USE __attribute__(()) int n) // expected-error {{'ATTR_NAME' only applies to function types}}
 322   ) {
 323   }
 324
 325   void f3(
 326     int (__attribute__(()) ATTR_USE int n) // expected-error {{'ATTR_NAME' cannot appear here}}
 327   ) {
 328   }
 329
 330   void f4(
 331       int (*)(__attribute__(()) ATTR_USE int n) // expected-error {{'ATTR_NAME' cannot appear here}}
 332   ) {
 333   }
 334 };
 335
 336 namespace base_specs {
 337 struct A {};
 338 struct B : ATTR_USE A {}; // expected-error {{'ATTR_NAME' cannot be applied to a base specifier}}
 339 struct C : ATTR_USE virtual A {}; // expected-error {{'ATTR_NAME' cannot be applied to a base specifier}}
 340 struct D : ATTR_USE public virtual A {}; // expected-error {{'ATTR_NAME' cannot be applied to a base specifier}}
 341 struct E : public ATTR_USE virtual A {}; // expected-error {{'ATTR_NAME' cannot appear here}} \
 342                                                    expected-error {{'ATTR_NAME' cannot be applied to a base specifier}}
 343 struct F : virtual ATTR_USE public A {}; // expected-error {{'ATTR_NAME' cannot appear here}} \
 344                                                    expected-error {{'ATTR_NAME' cannot be applied to a base specifier}}
 345 }
 346
 347 namespace ATTR_USE ns_attr {}; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}} \
 348                                          expected-warning {{attributes on a namespace declaration are a C++17 extension}}