Change c2x-attribute-keywords.c to test both forms

Author: sdesmalen-arm

clang/test/Parser/c2x-attribute-keywords.c

@@ -1,60 +1,64 @@
-// RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify=expected,notc2x -Wno-strict-prototypes %s
-// RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify=expected,c2x %s
-
-enum __arm_inout("za") E { // expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
-  One __arm_inout("za"), // expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
+// RUN: sed -e s/ATTR_USE/__arm_streaming/g -e s/ATTR_NAME/__arm_streaming/g %s > %t
+// RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify=expected,notc2x -Wno-strict-prototypes %t
+// RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify=expected,c2x %t
+// RUN: sed -e s/ATTR_USE/__arm_inout\(\"za\"\)/g -e s/ATTR_NAME/__arm_inout/g %s > %t
+// RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify=expected,notc2x -Wno-strict-prototypes %t
+// RUN: %clang_cc1 -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -verify=expected,c2x %t
+
+enum ATTR_USE E { // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
+  One ATTR_USE, // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
   Two,
-  Three __arm_inout("za") // expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
+  Three ATTR_USE // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 };
 
-enum __arm_inout("za") { Four }; // expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
-__arm_inout("za") enum E2 { Five }; // expected-error {{misplaced '__arm_inout'}}
+enum ATTR_USE { Four }; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
+ATTR_USE enum E2 { Five }; // expected-error {{misplaced 'ATTR_NAME'}}
 
 // FIXME: this diagnostic can be improved.
-enum { __arm_inout("za") Six }; // expected-error {{expected identifier}}
+enum { ATTR_USE Six }; // expected-error {{expected identifier}}
 
 // FIXME: this diagnostic can be improved.
-enum E3 __arm_inout("za") { Seven }; // expected-error {{expected identifier or '('}}
-
-struct __arm_inout("za") S1 { // expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
-  int i __arm_inout("za"); // expected-error {{'__arm_inout' only applies to function types}}
-  int __arm_inout("za") j; // expected-error {{'__arm_inout' only applies to function types}}
-  int k[10] __arm_inout("za"); // expected-error {{'__arm_inout' only applies to function types}}
-  int l __arm_inout("za")[10]; // expected-error {{'__arm_inout' only applies to function types}}
-  __arm_inout("za") int m, n; // expected-error {{'__arm_inout' only applies to function types}}
-  int o __arm_inout("za") : 12; // expected-error {{'__arm_inout' only applies to function types}}
-  int __arm_inout("za") : 0; // expected-error {{'__arm_inout' only applies to function types}}
-  int p, __arm_inout("za") : 0; // expected-error {{'__arm_inout' cannot appear here}}
-  int q, __arm_inout("za") r; // expected-error {{'__arm_inout' cannot appear here}}
-  __arm_inout("za") int; // expected-error {{'__arm_inout' cannot appear here}} \
+enum E3 ATTR_USE { Seven }; // expected-error {{expected identifier or '('}}
+
+struct ATTR_USE S1 { // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
+  int i ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
+  int ATTR_USE j; // expected-error {{'ATTR_NAME' only applies to function types}}
+  int k[10] ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
+  int l ATTR_USE[10]; // expected-error {{'ATTR_NAME' only applies to function types}}
+  ATTR_USE int m, n; // expected-error {{'ATTR_NAME' only applies to function types}}
+  int o ATTR_USE : 12; // expected-error {{'ATTR_NAME' only applies to function types}}
+  int ATTR_USE : 0; // expected-error {{'ATTR_NAME' only applies to function types}}
+  int p, ATTR_USE : 0; // expected-error {{'ATTR_NAME' cannot appear here}}
+  int q, ATTR_USE r; // expected-error {{'ATTR_NAME' cannot appear here}}
+  ATTR_USE int; // expected-error {{'ATTR_NAME' cannot appear here}} \
             // expected-warning {{declaration does not declare anything}}
 };
 
-__arm_inout("za") struct S2 { int a; }; // expected-error {{misplaced '__arm_inout'}}
-struct S3 __arm_inout("za") { int a; }; // expected-error {{'__arm_inout' cannot appear here}} \
-                                         expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
+ATTR_USE struct S2 { int a; }; // expected-error {{misplaced 'ATTR_NAME'}}
+struct S3 ATTR_USE { int a; }; // expected-error {{'ATTR_NAME' cannot appear here}} \
+                                         expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 
-union __arm_inout("za") U { // expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
-  double d __arm_inout("za"); // expected-error {{'__arm_inout' only applies to function types; type here is 'double'}}
-  __arm_inout("za") int i; // expected-error {{'__arm_inout' only applies to function types; type here is 'int'}}
+union ATTR_USE U { // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
+  double d ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types; type here is 'double'}}
+  ATTR_USE int i; // expected-error {{'ATTR_NAME' only applies to function types; type here is 'int'}}
 };
 
-__arm_inout("za") union U2 { double d; }; // expected-error {{misplaced '__arm_inout'}}
-union U3 __arm_inout("za") { double d; }; // expected-error {{'__arm_inout' cannot appear here}} \
-                                           expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
+ATTR_USE union U2 { double d; }; // expected-error {{misplaced 'ATTR_NAME'}}
+union U3 ATTR_USE { double d; }; // expected-error {{'ATTR_NAME' cannot appear here}} \
+                                           expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 
-struct __arm_inout("za") IncompleteStruct; // expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
-union __arm_inout("za") IncompleteUnion; // expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
-enum __arm_inout("za") IncompleteEnum; // expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
+struct ATTR_USE IncompleteStruct; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
+union ATTR_USE IncompleteUnion; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
+enum ATTR_USE IncompleteEnum; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 
-__arm_inout("za") void f1(void); // expected-error {{'__arm_inout' cannot be applied to a declaration}}
-void __arm_inout("za") f2(void); // expected-error {{'__arm_inout' only applies to function types}}
-void f3 __arm_inout("za") (void); // expected-error {{'__arm_inout' cannot be applied to a declaration}}
-void f4(void) __arm_inout("za");
+ATTR_USE void f1(void); // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
+void ATTR_USE f2(void); // expected-error {{'ATTR_NAME' only applies to function types}}
+void f3 ATTR_USE (void); // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
+void f4(void) ATTR_USE;
 
-void f5(int i __arm_inout("za"), __arm_inout("za") int j, int __arm_inout("za") k); // expected-error 3 {{'__arm_inout' only applies to function types}}
+void f5(int i ATTR_USE, ATTR_USE int j, int ATTR_USE k); // expected-error 3 {{'ATTR_NAME' only applies to function types}}
 
-void f6(a, b) __arm_inout("za") int a; int b; { // expected-error {{'__arm_inout' cannot appear here}} \
+void f6(a, b) ATTR_USE int a; int b; { // expected-error {{'ATTR_NAME' cannot appear here}} \
                                                  c2x-warning {{deprecated}}
 }
 
@@ -63,60 +67,60 @@ void f6(a, b) __arm_inout("za") int a; int b; { // expected-error {{'__arm_inout
 // behavior given that we *don't* want to parse it as part of the K&R parameter
 // declarations. It is disallowed to avoid a parsing ambiguity we already
 // handle well.
-int (*f7(a, b))(int, int) __arm_inout("za") int a; int b; { // c2x-warning {{deprecated}}
+int (*f7(a, b))(int, int) ATTR_USE int a; int b; { // c2x-warning {{deprecated}}
   return 0;
 }
 
-__arm_inout("za") int a, b; // expected-error {{'__arm_inout' only applies to function types}}
-int c __arm_inout("za"), d __arm_inout("za"); // expected-error 2 {{'__arm_inout' only applies to function types}}
+ATTR_USE int a, b; // expected-error {{'ATTR_NAME' only applies to function types}}
+int c ATTR_USE, d ATTR_USE; // expected-error 2 {{'ATTR_NAME' only applies to function types}}
 
-void f8(void) __arm_inout("za") {
-  __arm_inout("za") int i, j; // expected-error {{'__arm_inout' only applies to function types}}
-  int k, l __arm_inout("za"); // expected-error {{'__arm_inout' only applies to function types}}
+void f8(void) ATTR_USE {
+  ATTR_USE int i, j; // expected-error {{'ATTR_NAME' only applies to function types}}
+  int k, l ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
 }
 
-__arm_inout("za") void f9(void) { // expected-error {{'__arm_inout' cannot be applied to a declaration}}
-  int i[10] __arm_inout("za"); // expected-error {{'__arm_inout' only applies to function types}}
-  int (*fp1)(void)__arm_inout("za");
-  int (*fp2 __arm_inout("za"))(void); // expected-error {{'__arm_inout' cannot be applied to a declaration}}
+ATTR_USE void f9(void) { // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
+  int i[10] ATTR_USE; // expected-error {{'ATTR_NAME' only applies to function types}}
+  int (*fp1)(void)ATTR_USE;
+  int (*fp2 ATTR_USE)(void); // expected-error {{'ATTR_NAME' cannot be applied to a declaration}}
 
-  int * __arm_inout("za") *ipp; // expected-error {{'__arm_inout' only applies to function types}}
+  int * ATTR_USE *ipp; // expected-error {{'ATTR_NAME' only applies to function types}}
 }
 
-void f10(int j[static 10] __arm_inout("za"), int k[*] __arm_inout("za")); // expected-error 2 {{'__arm_inout' only applies to function types}}
+void f10(int j[static 10] ATTR_USE, int k[*] ATTR_USE); // expected-error 2 {{'ATTR_NAME' only applies to function types}}
 
 void f11(void) {
-  __arm_inout("za") {} // expected-error {{'__arm_inout' cannot be applied to a statement}}
-  __arm_inout("za") if (1) {} // expected-error {{'__arm_inout' cannot be applied to a statement}}
+  ATTR_USE {} // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
+  ATTR_USE if (1) {} // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 
-  __arm_inout("za") switch (1) { // expected-error {{'__arm_inout' cannot be applied to a statement}}
-  __arm_inout("za") case 1: __arm_inout("za") break; // expected-error 2 {{'__arm_inout' cannot be applied to a statement}}
-  __arm_inout("za") default: break; // expected-error {{'__arm_inout' cannot be applied to a statement}}
+  ATTR_USE switch (1) { // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
+  ATTR_USE case 1: ATTR_USE break; // expected-error 2 {{'ATTR_NAME' cannot be applied to a statement}}
+  ATTR_USE default: break; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
   }
 
   goto foo;
-  __arm_inout("za") foo: (void)1; // expected-error {{'__arm_inout' only applies to non-K&R-style functions}}
+  ATTR_USE foo: (void)1; // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}}
 
-  __arm_inout("za") for (;;); // expected-error {{'__arm_inout' cannot be applied to a statement}}
-  __arm_inout("za") while (1); // expected-error {{'__arm_inout' cannot be applied to a statement}}
-  __arm_inout("za") do __arm_inout("za") { } while(1); // expected-error 2 {{'__arm_inout' cannot be applied to a statement}}
+  ATTR_USE for (;;); // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
+  ATTR_USE while (1); // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
+  ATTR_USE do ATTR_USE { } while(1); // expected-error 2 {{'ATTR_NAME' cannot be applied to a statement}}
 
-  __arm_inout("za") (void)1; // expected-error {{'__arm_inout' cannot be applied to a statement}}
+  ATTR_USE (void)1; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 
-  __arm_inout("za"); // expected-error {{'__arm_inout' cannot be applied to a statement}}
+  ATTR_USE; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 
-  (void)sizeof(int [4]__arm_inout("za")); // expected-error {{'__arm_inout' only applies to function types}}
-  (void)sizeof(struct __arm_inout("za") S3 { int a __arm_inout("za"); }); // expected-error {{'__arm_inout' only applies to non-K&R-style functions}} \
-                                                                      // expected-error {{'__arm_inout' only applies to function types; type here is 'int'}}
+  (void)sizeof(int [4]ATTR_USE); // expected-error {{'ATTR_NAME' only applies to function types}}
+  (void)sizeof(struct ATTR_USE S3 { int a ATTR_USE; }); // expected-error {{'ATTR_NAME' only applies to non-K&R-style functions}} \
+                                                                      // expected-error {{'ATTR_NAME' only applies to function types; type here is 'int'}}
 
-  __arm_inout("za") return; // expected-error {{'__arm_inout' cannot be applied to a statement}}
+  ATTR_USE return; // expected-error {{'ATTR_NAME' cannot be applied to a statement}}
 
-  __arm_inout("za") asm (""); // expected-error {{'__arm_inout' cannot appear here}}
+  ATTR_USE asm (""); // expected-error {{'ATTR_NAME' cannot appear here}}
 }
 
-struct __arm_inout("za") S4 *s; // expected-error {{'__arm_inout' cannot appear here}}
+struct ATTR_USE S4 *s; // expected-error {{'ATTR_NAME' cannot appear here}}
 struct S5 {};
-int c = sizeof(struct __arm_inout("za") S5); // expected-error {{'__arm_inout' cannot appear here}}
+int c = sizeof(struct ATTR_USE S5); // expected-error {{'ATTR_NAME' cannot appear here}}
 
 void invalid_parentheses1() __arm_inout; // expected-error {{expected '(' after ''__arm_inout''}}
 void invalid_parentheses2() __arm_inout(; // expected-error {{expected string literal as argument of '__arm_inout' attribute}}