C2y has added support for static assertions as void expressions, in
addition to use as declarations (N3715 was accepted in an online vote
between meetings).
Implement the feature in GCC. There is a syntactic ambiguity between
a static assertion as a declaration and one as an expression
statement, which the accepted feature resolves by making such a usage
a declaration (this only affects the sequence of syntax productions by
which the code is parsed, not the actual semantics of the assertion);
I've raised the similar ambiguity in for loops on the WG14 reflector.
If just concerned with C2y, and not with diagnosing the use of a
feature not supported in older standard versions, the feature might be
simpler to implement by defaulting to treating static assertions in
ambiguous contexts as expressions rather than declarations, but that
would make it hard to diagnose exactly the cases that are new in C2y
(those depend on the static assertion either not being the whole
expression statement, or being in a context where an expression
statement is allowed but a declaration is not, e.g. the body of an if
statement). Instead, to support such diagnostics, the implementation
follows the standard in what is considered a declaration and what is
considered an expression, by looking ahead to what follows the closing
parenthesis when a static assertion starts in a context where a
declaration is permitted.
Bootstrapped with no regressions for x86_64-pc-linux-gnu.
gcc/c/
* c-parser.cc (c_parser_next_tokens_start_typename)
(c_parser_next_tokens_start_declaration): Add argument for token
to start from
(c_parser_next_tokens_start_declaration): Check for whether static
assertion followed by semicolon.
(c_parser_check_balanced_raw_token_sequence): Declare earlier.
(c_parser_compound_statement_nostart, c_parser_for_statement): Use
c_parser_next_tokens_start_declaration not
c_token_starts_declaration on second token.
(c_parser_unary_expression): Handle static assertions.
* c-parser.h (c_parser_next_tokens_start_declaration): Add
argument.
gcc/testsuite/
* gcc.dg/c23-static-assert-5.c, gcc.dg/c23-static-assert-6.c,
gcc.dg/c23-static-assert-7.c, gcc.dg/c23-static-assert-8.c,
gcc.dg/c2y-static-assert-2.c, gcc.dg/c2y-static-assert-3.c,
gcc.dg/c2y-static-assert-4.c: New tests.
diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc
index 56fb0be25b53..0cf3f92a72cb 100644
--- a/gcc/c/c-parser.cc
+++ b/gcc/c/c-parser.cc
@@ -675,14 +675,15 @@ c_token_starts_typename (c_token *token)
}
}
-/* Return true if the next token from PARSER can start a type name,
- false otherwise. LA specifies how to do lookahead in order to
+/* Return true if the next token from PARSER, starting from token N, can start
+ a type name, false otherwise. LA specifies how to do lookahead in order to
detect unknown type names. If unsure, pick CLA_PREFER_ID. */
static inline bool
-c_parser_next_tokens_start_typename (c_parser *parser, enum c_lookahead_kind
la)
+c_parser_next_tokens_start_typename (c_parser *parser, enum c_lookahead_kind
la,
+ unsigned int n = 1)
{
- c_token *token = c_parser_peek_token (parser);
+ c_token *token = c_parser_peek_nth_token (parser, n);
if (c_token_starts_typename (token))
return true;
@@ -695,8 +696,8 @@ c_parser_next_tokens_start_typename (c_parser *parser, enum
c_lookahead_kind la)
&& !parser->objc_could_be_foreach_context
&& (la == cla_prefer_type
- || c_parser_peek_2nd_token (parser)->type == CPP_NAME
- || c_parser_peek_2nd_token (parser)->type == CPP_MULT)
+ || c_parser_peek_nth_token (parser, n + 1)->type == CPP_NAME
+ || c_parser_peek_nth_token (parser, n + 1)->type == CPP_MULT)
/* Only unknown identifiers. */
&& !lookup_name (token->value))
@@ -892,30 +893,47 @@ c_parser_next_token_starts_declspecs (c_parser *parser)
return c_token_starts_declspecs (token);
}
-/* Return true if the next tokens from PARSER can start declaration
- specifiers (not including standard attributes) or a static
- assertion, false otherwise. */
+static bool c_parser_check_balanced_raw_token_sequence (c_parser *,
+ unsigned int *);
+
+/* Return true if the next tokens from PARSER (starting with token N, 1-based)
+ can start declaration specifiers (not including standard attributes) or a
+ static assertion, false otherwise. */
bool
-c_parser_next_tokens_start_declaration (c_parser *parser)
+c_parser_next_tokens_start_declaration (c_parser *parser, unsigned int n)
{
- c_token *token = c_parser_peek_token (parser);
+ c_token *token = c_parser_peek_nth_token (parser, n);
/* Same as above. */
if (c_dialect_objc ()
&& token->type == CPP_NAME
&& token->id_kind == C_ID_CLASSNAME
- && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
+ && c_parser_peek_nth_token (parser, n + 1)->type == CPP_DOT)
return false;
/* Labels do not start declarations. */
if (token->type == CPP_NAME
- && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
+ && c_parser_peek_nth_token (parser, n + 1)->type == CPP_COLON)
return false;
+ /* A static assertion is only a declaration if followed by a semicolon;
+ otherwise, it may be an expression in C2Y. */
+ if (token->keyword == RID_STATIC_ASSERT
+ && c_parser_peek_nth_token (parser, n + 1)->type == CPP_OPEN_PAREN)
+ {
+ n += 2;
+ if (!c_parser_check_balanced_raw_token_sequence (parser, &n)
+ || c_parser_peek_nth_token_raw (parser, n)->type != CPP_CLOSE_PAREN)
+ /* Invalid static assertion syntax; treat as a declaration and report a
+ syntax error there. */
+ return true;
+ return c_parser_peek_nth_token_raw (parser, n + 1)->type ==
CPP_SEMICOLON;
+ }
+
if (c_token_starts_declaration (token))
return true;
- if (c_parser_next_tokens_start_typename (parser, cla_nonabstract_decl))
+ if (c_parser_next_tokens_start_typename (parser, cla_nonabstract_decl, n))
return true;
return false;
@@ -5855,9 +5873,6 @@ c_parser_balanced_token_sequence (c_parser *parser)
}
}
-static bool c_parser_check_balanced_raw_token_sequence (c_parser *,
- unsigned int *);
-
/* Parse arguments of omp::directive or omp::decl attribute.
directive-name ,[opt] clause-list[opt]
@@ -7724,7 +7739,7 @@ c_parser_compound_statement_nostart (c_parser *parser)
== RID_EXTENSION))
c_parser_consume_token (parser);
if (!have_std_attrs
- && (c_token_starts_declaration (c_parser_peek_2nd_token (parser))
+ && (c_parser_next_tokens_start_declaration (parser, 2)
|| c_parser_nth_token_starts_std_attributes (parser, 2)))
{
int ext;
@@ -9132,7 +9147,7 @@ c_parser_for_statement (c_parser *parser, bool ivdep,
unsigned short unroll,
&& (c_parser_peek_2nd_token (parser)->keyword
== RID_EXTENSION))
c_parser_consume_token (parser);
- if (c_token_starts_declaration (c_parser_peek_2nd_token (parser))
+ if (c_parser_next_tokens_start_declaration (parser, 2)
|| c_parser_nth_token_starts_std_attributes (parser, 2))
{
int ext;
@@ -10513,8 +10528,9 @@ c_parser_cast_expression (c_parser *parser, struct
c_expr *after)
_Countof ( type-name )
sizeof unary-expression
sizeof ( type-name )
+ static-assert-declaration-no-semi
- (_Countof is new in C2y.)
+ (_Countof and the use of static assertions in expressions are new in C2y.)
unary-operator: one of
& * + - ~ !
@@ -10679,6 +10695,15 @@ c_parser_unary_expression (c_parser *parser)
case RID_TRANSACTION_RELAXED:
return c_parser_transaction_expression (parser,
c_parser_peek_token (parser)->keyword);
+ case RID_STATIC_ASSERT:
+ c_parser_static_assert_declaration_no_semi (parser);
+ pedwarn_c23 (op_loc, OPT_Wpedantic,
+ "ISO C does not support static assertions in "
+ "expressions before C2Y");
+ ret.value = void_node;
+ set_c_expr_source_range (&ret, op_loc, op_loc);
+ ret.m_decimal = 0;
+ return ret;
default:
return c_parser_postfix_expression (parser);
}
diff --git a/gcc/c/c-parser.h b/gcc/c/c-parser.h
index a84779bcbf83..46713d715ac7 100644
--- a/gcc/c/c-parser.h
+++ b/gcc/c/c-parser.h
@@ -156,7 +156,8 @@ extern void c_parser_skip_until_found (c_parser *parser,
enum cpp_ttype type,
const char *msgid,
location_t = UNKNOWN_LOCATION);
extern bool c_parser_next_token_starts_declspecs (c_parser *parser);
-bool c_parser_next_tokens_start_declaration (c_parser *parser);
+bool c_parser_next_tokens_start_declaration (c_parser *parser,
+ unsigned int n = 1);
bool c_token_starts_typename (c_token *token);
/* Abstraction to avoid defining c_parser here which messes up gengtype
diff --git a/gcc/testsuite/gcc.dg/c23-static-assert-5.c
b/gcc/testsuite/gcc.dg/c23-static-assert-5.c
new file mode 100644
index 000000000000..2edc6b77c0c1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-static-assert-5.c
@@ -0,0 +1,69 @@
+/* Test C2y static assertions in expressions: -pedantic warnings for C23. */
+/* { dg-do compile } */
+/* { dg-options "-std=c23 -pedantic" } */
+
+/* Old forms of static assertion still valid. */
+static_assert (1);
+static_assert (2, "message" );
+struct s { int a; static_assert (3); };
+
+void
+f ()
+{
+ static_assert (4);
+ label:
+ static_assert (5);
+ for (static_assert (6);;)
+ ;
+}
+
+/* Test new forms of static assertion. */
+void
+g ()
+{
+ (void) 0, static_assert (7), (void) 0; /* { dg-warning "ISO C does not
support static assertions in expressions before C2Y" } */
+ extern typeof (static_assert (8)) f (); /* { dg-warning "ISO C does not
support static assertions in expressions before C2Y" } */
+ 1
+ ? static_assert (9) /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ : static_assert (10); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ if (1)
+ static_assert (11); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ else
+ static_assert (12); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ for (;;)
+ static_assert (13); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ while (true)
+ static_assert (14); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ do
+ static_assert (15); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ while (false);
+ switch (16)
+ static_assert (17); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ (void) static_assert (18); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ (static_assert (19)); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+}
+
+void
+g2 ()
+{
+ (void) 0, static_assert (7, "message"), (void) 0; /* { dg-warning "ISO C
does not support static assertions in expressions before C2Y" } */
+ extern typeof (static_assert (8, "message")) f (); /* { dg-warning "ISO C
does not support static assertions in expressions before C2Y" } */
+ 1
+ ? static_assert (9, "message") /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ : static_assert (10, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ if (1)
+ static_assert (11, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ else
+ static_assert (12, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ for (;;)
+ static_assert (13, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ while (true)
+ static_assert (14, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ do
+ static_assert (15, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ while (false);
+ switch (16)
+ static_assert (17, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ (void) static_assert (18, "message"); /* { dg-warning "ISO C does not
support static assertions in expressions before C2Y" } */
+ (static_assert (19, "message")); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+}
diff --git a/gcc/testsuite/gcc.dg/c23-static-assert-6.c
b/gcc/testsuite/gcc.dg/c23-static-assert-6.c
new file mode 100644
index 000000000000..43e0b27c4220
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-static-assert-6.c
@@ -0,0 +1,70 @@
+/* Test C2y static assertions in expressions: -pedantic-errors errors for
+ C23. */
+/* { dg-do compile } */
+/* { dg-options "-std=c23 -pedantic-errors" } */
+
+/* Old forms of static assertion still valid. */
+static_assert (1);
+static_assert (2, "message" );
+struct s { int a; static_assert (3); };
+
+void
+f ()
+{
+ static_assert (4);
+ label:
+ static_assert (5);
+ for (static_assert (6);;)
+ ;
+}
+
+/* Test new forms of static assertion. */
+void
+g ()
+{
+ (void) 0, static_assert (7), (void) 0; /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+ extern typeof (static_assert (8)) f (); /* { dg-error "ISO C does not
support static assertions in expressions before C2Y" } */
+ 1
+ ? static_assert (9) /* { dg-error "ISO C does not support static
assertions in expressions before C2Y" } */
+ : static_assert (10); /* { dg-error "ISO C does not support static
assertions in expressions before C2Y" } */
+ if (1)
+ static_assert (11); /* { dg-error "ISO C does not support static
assertions in expressions before C2Y" } */
+ else
+ static_assert (12); /* { dg-error "ISO C does not support static
assertions in expressions before C2Y" } */
+ for (;;)
+ static_assert (13); /* { dg-error "ISO C does not support static
assertions in expressions before C2Y" } */
+ while (true)
+ static_assert (14); /* { dg-error "ISO C does not support static
assertions in expressions before C2Y" } */
+ do
+ static_assert (15); /* { dg-error "ISO C does not support static
assertions in expressions before C2Y" } */
+ while (false);
+ switch (16)
+ static_assert (17); /* { dg-error "ISO C does not support static
assertions in expressions before C2Y" } */
+ (void) static_assert (18); /* { dg-error "ISO C does not support static
assertions in expressions before C2Y" } */
+ (static_assert (19)); /* { dg-error "ISO C does not support static
assertions in expressions before C2Y" } */
+}
+
+void
+g2 ()
+{
+ (void) 0, static_assert (7, "message"), (void) 0; /* { dg-error "ISO C does
not support static assertions in expressions before C2Y" } */
+ extern typeof (static_assert (8, "message")) f (); /* { dg-error "ISO C does
not support static assertions in expressions before C2Y" } */
+ 1
+ ? static_assert (9, "message") /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+ : static_assert (10, "message"); /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+ if (1)
+ static_assert (11, "message"); /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+ else
+ static_assert (12, "message"); /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+ for (;;)
+ static_assert (13, "message"); /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+ while (true)
+ static_assert (14, "message"); /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+ do
+ static_assert (15, "message"); /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+ while (false);
+ switch (16)
+ static_assert (17, "message"); /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+ (void) static_assert (18, "message"); /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+ (static_assert (19, "message")); /* { dg-error "ISO C does not support
static assertions in expressions before C2Y" } */
+}
diff --git a/gcc/testsuite/gcc.dg/c23-static-assert-7.c
b/gcc/testsuite/gcc.dg/c23-static-assert-7.c
new file mode 100644
index 000000000000..9c35353be82e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-static-assert-7.c
@@ -0,0 +1,70 @@
+/* Test C2y static assertions in expressions: -Wc23-c2y-compat warnings for
+ C23. */
+/* { dg-do compile } */
+/* { dg-options "-std=c23 -Wc23-c2y-compat" } */
+
+/* Old forms of static assertion still valid. */
+static_assert (1);
+static_assert (2, "message" );
+struct s { int a; static_assert (3); };
+
+void
+f ()
+{
+ static_assert (4);
+ label:
+ static_assert (5);
+ for (static_assert (6);;)
+ ;
+}
+
+/* Test new forms of static assertion. */
+void
+g ()
+{
+ (void) 0, static_assert (7), (void) 0; /* { dg-warning "ISO C does not
support static assertions in expressions before C2Y" } */
+ extern typeof (static_assert (8)) f (); /* { dg-warning "ISO C does not
support static assertions in expressions before C2Y" } */
+ 1
+ ? static_assert (9) /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ : static_assert (10); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ if (1)
+ static_assert (11); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ else
+ static_assert (12); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ for (;;)
+ static_assert (13); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ while (true)
+ static_assert (14); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ do
+ static_assert (15); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ while (false);
+ switch (16)
+ static_assert (17); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ (void) static_assert (18); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ (static_assert (19)); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+}
+
+void
+g2 ()
+{
+ (void) 0, static_assert (7, "message"), (void) 0; /* { dg-warning "ISO C
does not support static assertions in expressions before C2Y" } */
+ extern typeof (static_assert (8, "message")) f (); /* { dg-warning "ISO C
does not support static assertions in expressions before C2Y" } */
+ 1
+ ? static_assert (9, "message") /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ : static_assert (10, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ if (1)
+ static_assert (11, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ else
+ static_assert (12, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ for (;;)
+ static_assert (13, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ while (true)
+ static_assert (14, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ do
+ static_assert (15, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ while (false);
+ switch (16)
+ static_assert (17, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ (void) static_assert (18, "message"); /* { dg-warning "ISO C does not
support static assertions in expressions before C2Y" } */
+ (static_assert (19, "message")); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+}
diff --git a/gcc/testsuite/gcc.dg/c23-static-assert-8.c
b/gcc/testsuite/gcc.dg/c23-static-assert-8.c
new file mode 100644
index 000000000000..118e199d37ad
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-static-assert-8.c
@@ -0,0 +1,66 @@
+/* Test C2y static assertions in expressions: not diagnosed for C23 with
+ -pedantic-errors -Wno-c23-c2y-compat. */
+/* { dg-do compile } */
+/* { dg-options "-std=c23 -pedantic-errors -Wno-c23-c2y-compat" } */
+
+/* Old forms of static assertion still valid. */
+static_assert (1);
+static_assert (2, "message" );
+struct s { int a; static_assert (3); };
+
+void
+f ()
+{
+ static_assert (4);
+ label:
+ static_assert (5);
+ for (static_assert (6);;)
+ ;
+}
+
+/* Test new forms of static assertion. */
+void
+g ()
+{
+ (void) 0, static_assert (7), (void) 0;
+ extern typeof (static_assert (8)) f ();
+ 1 ? static_assert (9) : static_assert (10);
+ if (1)
+ static_assert (11);
+ else
+ static_assert (12);
+ for (;;)
+ static_assert (13);
+ while (true)
+ static_assert (14);
+ do
+ static_assert (15);
+ while (false);
+ switch (16)
+ static_assert (17);
+ (void) static_assert (18);
+ (static_assert (19));
+}
+
+void
+g2 ()
+{
+ (void) 0, static_assert (7, "message"), (void) 0;
+ extern typeof (static_assert (8, "message")) f ();
+ 1 ? static_assert (9, "message") : static_assert (10, "message");
+ if (1)
+ static_assert (11, "message");
+ else
+ static_assert (12, "message");
+ for (;;)
+ static_assert (13, "message");
+ while (true)
+ static_assert (14, "message");
+ do
+ static_assert (15, "message");
+ while (false);
+ switch (16)
+ static_assert (17, "message");
+ (void) static_assert (18, "message");
+ (static_assert (19, "message"));
+}
diff --git a/gcc/testsuite/gcc.dg/c2y-static-assert-2.c
b/gcc/testsuite/gcc.dg/c2y-static-assert-2.c
new file mode 100644
index 000000000000..81cdd9dd3c67
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c2y-static-assert-2.c
@@ -0,0 +1,65 @@
+/* Test C2y static assertions in expressions. */
+/* { dg-do compile } */
+/* { dg-options "-std=c2y -pedantic-errors" } */
+
+/* Old forms of static assertion still valid. */
+static_assert (1);
+static_assert (2, "message" );
+struct s { int a; static_assert (3); };
+
+void
+f ()
+{
+ static_assert (4);
+ label:
+ static_assert (5);
+ for (static_assert (6);;)
+ ;
+}
+
+/* Test new forms of static assertion. */
+void
+g ()
+{
+ (void) 0, static_assert (7), (void) 0;
+ extern typeof (static_assert (8)) f ();
+ 1 ? static_assert (9) : static_assert (10);
+ if (1)
+ static_assert (11);
+ else
+ static_assert (12);
+ for (;;)
+ static_assert (13);
+ while (true)
+ static_assert (14);
+ do
+ static_assert (15);
+ while (false);
+ switch (16)
+ static_assert (17);
+ (void) static_assert (18);
+ (static_assert (19));
+}
+
+void
+g2 ()
+{
+ (void) 0, static_assert (7, "message"), (void) 0;
+ extern typeof (static_assert (8, "message")) f ();
+ 1 ? static_assert (9, "message") : static_assert (10, "message");
+ if (1)
+ static_assert (11, "message");
+ else
+ static_assert (12, "message");
+ for (;;)
+ static_assert (13, "message");
+ while (true)
+ static_assert (14, "message");
+ do
+ static_assert (15, "message");
+ while (false);
+ switch (16)
+ static_assert (17, "message");
+ (void) static_assert (18, "message");
+ (static_assert (19, "message"));
+}
diff --git a/gcc/testsuite/gcc.dg/c2y-static-assert-3.c
b/gcc/testsuite/gcc.dg/c2y-static-assert-3.c
new file mode 100644
index 000000000000..fcbf6afb7744
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c2y-static-assert-3.c
@@ -0,0 +1,69 @@
+/* Test C2y static assertions in expressions: -Wc23-c2y-compat warnings. */
+/* { dg-do compile } */
+/* { dg-options "-std=c2y -pedantic-errors -Wc23-c2y-compat" } */
+
+/* Old forms of static assertion still valid. */
+static_assert (1);
+static_assert (2, "message" );
+struct s { int a; static_assert (3); };
+
+void
+f ()
+{
+ static_assert (4);
+ label:
+ static_assert (5);
+ for (static_assert (6);;)
+ ;
+}
+
+/* Test new forms of static assertion. */
+void
+g ()
+{
+ (void) 0, static_assert (7), (void) 0; /* { dg-warning "ISO C does not
support static assertions in expressions before C2Y" } */
+ extern typeof (static_assert (8)) f (); /* { dg-warning "ISO C does not
support static assertions in expressions before C2Y" } */
+ 1
+ ? static_assert (9) /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ : static_assert (10); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ if (1)
+ static_assert (11); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ else
+ static_assert (12); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ for (;;)
+ static_assert (13); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ while (true)
+ static_assert (14); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ do
+ static_assert (15); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ while (false);
+ switch (16)
+ static_assert (17); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ (void) static_assert (18); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+ (static_assert (19)); /* { dg-warning "ISO C does not support static
assertions in expressions before C2Y" } */
+}
+
+void
+g2 ()
+{
+ (void) 0, static_assert (7, "message"), (void) 0; /* { dg-warning "ISO C
does not support static assertions in expressions before C2Y" } */
+ extern typeof (static_assert (8, "message")) f (); /* { dg-warning "ISO C
does not support static assertions in expressions before C2Y" } */
+ 1
+ ? static_assert (9, "message") /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ : static_assert (10, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ if (1)
+ static_assert (11, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ else
+ static_assert (12, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ for (;;)
+ static_assert (13, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ while (true)
+ static_assert (14, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ do
+ static_assert (15, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ while (false);
+ switch (16)
+ static_assert (17, "message"); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+ (void) static_assert (18, "message"); /* { dg-warning "ISO C does not
support static assertions in expressions before C2Y" } */
+ (static_assert (19, "message")); /* { dg-warning "ISO C does not support
static assertions in expressions before C2Y" } */
+}
diff --git a/gcc/testsuite/gcc.dg/c2y-static-assert-4.c
b/gcc/testsuite/gcc.dg/c2y-static-assert-4.c
new file mode 100644
index 000000000000..87eb7c8da6e5
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c2y-static-assert-4.c
@@ -0,0 +1,69 @@
+/* Test C2y static assertions in expressions: failed assertions. */
+/* { dg-do compile } */
+/* { dg-options "-std=c2y -pedantic-errors" } */
+
+/* Old forms of static assertion still valid. */
+static_assert (0); /* { dg-error "static assertion failed" } */
+static_assert (0, "message" ); /* { dg-error "static assertion failed" } */
+struct s { int a; static_assert (0); }; /* { dg-error "static assertion
failed" } */
+
+void
+f ()
+{
+ static_assert (0); /* { dg-error "static assertion failed" } */
+ label:
+ static_assert (0); /* { dg-error "static assertion failed" } */
+ for (static_assert (0);;) /* { dg-error "static assertion failed" } */
+ ;
+}
+
+/* Test new forms of static assertion. */
+void
+g ()
+{
+ (void) 0, static_assert (0), (void) 0; /* { dg-error "static assertion
failed" } */
+ extern typeof (static_assert (0)) f (); /* { dg-error "static assertion
failed" } */
+ 1
+ ? static_assert (0) /* { dg-error "static assertion failed" } */
+ : static_assert (0); /* { dg-error "static assertion failed" } */
+ if (1)
+ static_assert (0); /* { dg-error "static assertion failed" } */
+ else
+ static_assert (0); /* { dg-error "static assertion failed" } */
+ for (;;)
+ static_assert (0); /* { dg-error "static assertion failed" } */
+ while (true)
+ static_assert (0); /* { dg-error "static assertion failed" } */
+ do
+ static_assert (0); /* { dg-error "static assertion failed" } */
+ while (false);
+ switch (16)
+ static_assert (0); /* { dg-error "static assertion failed" } */
+ (void) static_assert (0); /* { dg-error "static assertion failed" } */
+ (static_assert (0)); /* { dg-error "static assertion failed" } */
+}
+
+void
+g2 ()
+{
+ (void) 0, static_assert (0, "message"), (void) 0; /* { dg-error "static
assertion failed" } */
+ extern typeof (static_assert (0, "message")) f (); /* { dg-error "static
assertion failed" } */
+ 1
+ ? static_assert (0, "message") /* { dg-error "static assertion failed" } */
+ : static_assert (0, "message"); /* { dg-error "static assertion failed" }
*/
+ if (1)
+ static_assert (0, "message"); /* { dg-error "static assertion failed" } */
+ else
+ static_assert (0, "message"); /* { dg-error "static assertion failed" } */
+ for (;;)
+ static_assert (0, "message"); /* { dg-error "static assertion failed" } */
+ while (true)
+ static_assert (0, "message"); /* { dg-error "static assertion failed" } */
+ do
+ static_assert (0, "message"); /* { dg-error "static assertion failed" } */
+ while (false);
+ switch (16)
+ static_assert (0, "message"); /* { dg-error "static assertion failed" } */
+ (void) static_assert (0, "message"); /* { dg-error "static assertion failed"
} */
+ (static_assert (0, "message")); /* { dg-error "static assertion failed" } */
+}
--
Joseph S. Myers
[email protected]
