[PATCH 48/73] c23: Support labels before declarations and at block ends

[Bart Van Assche <bvanassche@acm.org>]

Allow named, case, and default labels (including chained labels) to
precede declarations and closing '}' braces inside compound statements
per ISO C23 6.8.1 and 6.8.2:
- Handle label chains at the block-item level in statement_list() by
  attaching a synthesized empty statement when a label precedes a
  declaration, static_assert, or '}', and emit pedantic warnings in
  pre-C23 modes.
- Keep substatements of selection and iteration statements restricted to
  true statements in statement() so invalid forms such as
  'if (c) int x = 1;' and '{ if (c) lbl: }' are rejected cleanly.
- Recognize labels whose identifier shadows an outer typedef name.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 parse.c                          | 206 ++++++++++++++++++++++---------
 validation/c23-labels-error.c    |  48 +++++++
 validation/c23-labels-gnu.c      |  15 +++
 validation/c23-labels-pedantic.c |  15 +++
 validation/c23-labels.c          |  67 ++++++++++
 5 files changed, 296 insertions(+), 55 deletions(-)
 create mode 100644 validation/c23-labels-error.c
 create mode 100644 validation/c23-labels-gnu.c
 create mode 100644 validation/c23-labels-pedantic.c
 create mode 100644 validation/c23-labels.c

diff --git a/parse.c b/parse.c
index 78ad5f09e2ad..1e91825f8d38 100644
--- a/parse.c
+++ b/parse.c
@@ -62,8 +62,6 @@ static declarator_t autotype_specifier;
 static struct token *parse_if_statement(struct token *token, struct statement *stmt);
 static struct token *parse_return_statement(struct token *token, struct statement *stmt);
 static struct token *parse_loop_iterator(struct token *token, struct statement *stmt);
-static struct token *parse_default_statement(struct token *token, struct statement *stmt);
-static struct token *parse_case_statement(struct token *token, struct statement *stmt);
 static struct token *parse_switch_statement(struct token *token, struct statement *stmt);
 static struct token *parse_for_statement(struct token *token, struct statement *stmt);
 static struct token *parse_while_statement(struct token *token, struct statement *stmt);
@@ -315,11 +313,9 @@ static struct symbol_op loop_iter_op = {
 };
 
 static struct symbol_op default_op = {
-	.statement = parse_default_statement,
 };
 
 static struct symbol_op case_op = {
-	.statement = parse_case_statement,
 };
 
 static struct symbol_op switch_op = {
@@ -2518,32 +2514,6 @@ static struct token *parse_if_statement(struct token *token, struct statement *s
 	return statement(token->next, &stmt->if_false);
 }
 
-static inline struct token *case_statement(struct token *token, struct statement *stmt)
-{
-	stmt->type = STMT_CASE;
-	token = expect(token, ':', "after default/case");
-	add_case_statement(stmt);
-	if (match_op(token, '}')) {
-		warning(token->pos, "statement expected after case label");
-		stmt->case_statement = alloc_statement(token->pos, STMT_NONE);
-		return token;
-	}
-	return statement(token, &stmt->case_statement);
-}
-
-static struct token *parse_case_statement(struct token *token, struct statement *stmt)
-{
-	token = parse_expression(token->next, &stmt->case_expression);
-	if (match_op(token, SPECIAL_ELLIPSIS))
-		token = parse_expression(token->next, &stmt->case_to);
-	return case_statement(token, stmt);
-}
-
-static struct token *parse_default_statement(struct token *token, struct statement *stmt)
-{
-	return case_statement(token->next, stmt);
-}
-
 static struct token *parse_loop_iterator(struct token *token, struct statement *stmt)
 {
 	struct symbol *target = lookup_symbol(token->ident, NS_ITERATOR);
@@ -2646,46 +2616,129 @@ static struct token *handle_label_attributes(struct token *token, struct symbol
 	return token;
 }
 
+static bool is_label_token(struct token *token)
+{
+	struct token *p = token;
+	struct symbol *s;
+
+	if (token_type(p) != TOKEN_IDENT)
+		return false;
+	if (p->ident == &case_ident || p->ident == &default_ident)
+		return true;
+	s = lookup_keyword(p->ident, NS_KEYWORD);
+	if (s && s->op->statement)
+		return false;
+	if (p->ident->reserved)
+		return false;
+	return match_op(p->next, ':');
+}
+
+static struct token *parse_one_label(struct token *token,
+				     struct statement **stmtp,
+				     bool *is_case)
+{
+	struct decl_state attr_state = { };
+	struct statement *stmt;
+
+	*stmtp = NULL;
+	*is_case = false;
+
+	if (token->ident == &case_ident) {
+		stmt = alloc_statement(token->pos, STMT_CASE);
+		token = parse_expression(token->next, &stmt->case_expression);
+		if (match_op(token, SPECIAL_ELLIPSIS))
+			token = parse_expression(token->next, &stmt->case_to);
+		token = expect(token, ':', "after default/case");
+		add_case_statement(stmt);
+		*stmtp = stmt;
+		*is_case = true;
+		return token;
+	}
+	if (token->ident == &default_ident) {
+		stmt = alloc_statement(token->pos, STMT_CASE);
+		token = expect(token->next, ':', "after default/case");
+		add_case_statement(stmt);
+		*stmtp = stmt;
+		*is_case = true;
+		return token;
+	}
+
+	{
+		struct position pos = token->pos;
+		struct symbol *s = label_symbol(token, 0);
+		s->label_modifiers |= attr_state.ctype.modifiers;
+		token = handle_label_attributes(token->next->next, s);
+		if (s->stmt) {
+			sparse_error(pos, "label '%s' redefined",
+				     show_ident(s->ident));
+			return token;
+		}
+		stmt = alloc_statement(pos, STMT_LABEL);
+		stmt->label_identifier = s;
+		stmt->label_scope = label_scope;
+		if (s->label_scope) {
+			if (!is_in_scope(label_scope, s->label_scope))
+				warn_label_usage(stmt->pos, s->label_pos,
+						 s->ident);
+		}
+		s->stmt = stmt;
+		*stmtp = stmt;
+		return token;
+	}
+}
+
 static struct token *statement(struct token *token, struct statement **tree)
 {
 	struct statement *stmt = alloc_statement(token->pos, STMT_NONE);
 
+	if (is_label_token(token)) {
+		struct statement *lbl = NULL;
+		bool is_case = false;
+
+		token = parse_one_label(token, &lbl, &is_case);
+		if (!lbl)
+			return statement(token, tree);
+		*tree = lbl;
+		tree = is_case ? &lbl->case_statement : &lbl->label_statement;
+		if (match_op(token, '}')) {
+			sparse_error(token->pos,
+				     is_case ? "statement expected after case label" :
+					       "statement expected after label");
+			*tree = alloc_statement(token->pos, STMT_NONE);
+			return token;
+		}
+		return statement(token, tree);
+	}
+
 	*tree = stmt;
 	if (token_type(token) == TOKEN_IDENT) {
 		struct symbol *s = lookup_keyword(token->ident, NS_KEYWORD);
 		if (s && s->op->statement)
 			return s->op->statement(token, stmt);
-
-		if (match_op(token->next, ':')) {
-			struct symbol *s = label_symbol(token, 0);
-			token = handle_label_attributes(token->next->next, s);
-			if (s->stmt) {
-				sparse_error(stmt->pos, "label '%s' redefined", show_ident(s->ident));
-				// skip the label to avoid multiple definitions
-				return statement(token, tree);
-			}
-			stmt->type = STMT_LABEL;
-			stmt->label_identifier = s;
-			stmt->label_scope = label_scope;
-			if (s->label_scope) {
-				if (!is_in_scope(label_scope, s->label_scope))
-					warn_label_usage(stmt->pos, s->label_pos, s->ident);
-			}
-			s->stmt = stmt;
-			if (match_op(token, '}')) {
-				warning(token->pos, "statement expected after label");
-				stmt->label_statement = alloc_statement(token->pos, STMT_NONE);
-				return token;
-			}
-			return statement(token, &stmt->label_statement);
-		}
 	}
 
 	if (match_op(token, '{')) {
 		token = compound_statement(token->next, stmt);
 		return expect(token, '}', "at end of compound statement");
 	}
-			
+
+	if (match_ident(token, &_Static_assert_ident) ||
+	    (standard >= STANDARD_C23 &&
+	     match_ident(token, &static_assert_ident))) {
+		sparse_error(token->pos, "declaration is not a statement");
+		stmt->type = STMT_NONE;
+		return parse_static_assert(token, NULL);
+	}
+
+	if (lookup_type(token)) {
+		sparse_error(token->pos, "declaration is not a statement");
+		stmt->type = STMT_DECLARATION;
+		start_block_scope();
+		token = external_declaration(token, &stmt->declaration, NULL);
+		end_block_scope();
+		return token;
+	}
+
 	stmt->type = STMT_EXPRESSION;
 	return expression_statement(token, &stmt->expression);
 }
@@ -2714,6 +2767,49 @@ static struct token * statement_list(struct token *token, struct statement_list
 		token = label_statement(token->next);
 	for (;;) {
 		struct statement * stmt;
+		struct statement *label_head = NULL;
+		struct statement **label_tail = &label_head;
+		bool last_is_case = false;
+
+		while (is_label_token(token)) {
+			struct statement *lbl = NULL;
+			bool is_case = false;
+
+			token = parse_one_label(token, &lbl, &is_case);
+			if (!lbl)
+				continue;
+			*label_tail = lbl;
+			label_tail = is_case ? &lbl->case_statement :
+					       &lbl->label_statement;
+			last_is_case = is_case;
+		}
+		if (label_head) {
+			if (eof_token(token) || match_op(token, '}')) {
+				if (standard < STANDARD_C23)
+					warning(token->pos,
+						last_is_case ? "statement expected after case label" :
+							       "statement expected after label");
+				*label_tail = alloc_statement(token->pos, STMT_NONE);
+				add_statement(list, label_head);
+				break;
+			}
+			if (match_ident(token, &_Static_assert_ident) ||
+			    (standard >= STANDARD_C23 &&
+			     match_ident(token, &static_assert_ident)) ||
+			    lookup_type(token)) {
+				if (standard < STANDARD_C23 && Wpedantic)
+					warning(token->pos,
+						"a label can only be part of a statement and a declaration is not a statement");
+				*label_tail = alloc_statement(token->pos, STMT_NONE);
+				add_statement(list, label_head);
+			} else {
+				seen_statement = Wdeclarationafterstatement;
+				token = statement(token, label_tail);
+				add_statement(list, label_head);
+				continue;
+			}
+		}
+
 		if (eof_token(token))
 			break;
 		if (match_op(token, '}'))
diff --git a/validation/c23-labels-error.c b/validation/c23-labels-error.c
new file mode 100644
index 000000000000..55ee5bfd5b47
--- /dev/null
+++ b/validation/c23-labels-error.c
@@ -0,0 +1,48 @@
+static void test_dup(void)
+{
+dup:
+	;
+dup:
+	;
+}
+
+static void test_if_decl(int c)
+{
+	if (c)
+		int x = 1;
+}
+
+static void test_if_label_decl(int c)
+{
+	if (c)
+	lbl1:
+		int y = 2;
+}
+
+static void test_if_label_end(int c)
+{
+	if (c)
+	lbl2:
+}
+
+static void test_outside_switch(void)
+{
+	case 1:
+		;
+	default:
+		;
+}
+
+/*
+ * check-name: c23-labels-error
+ * check-command: sparse -std=c23 -Wno-decl $file
+ *
+ * check-error-start
+c23-labels-error.c:5:1: error: label 'dup' redefined
+c23-labels-error.c:12:17: error: declaration is not a statement
+c23-labels-error.c:19:17: error: declaration is not a statement
+c23-labels-error.c:26:1: error: statement expected after label
+c23-labels-error.c:30:9: error: not in switch scope
+c23-labels-error.c:32:9: error: not in switch scope
+ * check-error-end
+ */
diff --git a/validation/c23-labels-gnu.c b/validation/c23-labels-gnu.c
new file mode 100644
index 000000000000..15dcb20be1d8
--- /dev/null
+++ b/validation/c23-labels-gnu.c
@@ -0,0 +1,15 @@
+static int test_gnu_case_range(int c)
+{
+	switch (c) {
+	case 1 ... 5:
+		int a = 3;
+		return a;
+	case 6 ... 9:
+	}
+	return 0;
+}
+
+/*
+ * check-name: c23-labels-gnu
+ * check-command: sparse -std=gnu23 -Wno-decl $file
+ */
diff --git a/validation/c23-labels-pedantic.c b/validation/c23-labels-pedantic.c
new file mode 100644
index 000000000000..6048f2e48e96
--- /dev/null
+++ b/validation/c23-labels-pedantic.c
@@ -0,0 +1,15 @@
+static void test_label_decl(void)
+{
+	goto lbl;
+lbl:
+	int x = 42;
+}
+
+/*
+ * check-name: c23-labels-pedantic
+ * check-command: sparse -std=c11 -pedantic -Wno-decl $file
+ *
+ * check-error-start
+c23-labels-pedantic.c:5:9: warning: a label can only be part of a statement and a declaration is not a statement
+ * check-error-end
+ */
diff --git a/validation/c23-labels.c b/validation/c23-labels.c
new file mode 100644
index 000000000000..b4d90edbe666
--- /dev/null
+++ b/validation/c23-labels.c
@@ -0,0 +1,67 @@
+typedef int T_shadow;
+
+static int test_label_decl(void)
+{
+	goto lbl;
+lbl:
+lbl_chain:
+	int x = 42;
+	if (!x)
+		goto lbl_chain;
+	return x;
+}
+
+static int test_case_decl(int c)
+{
+	switch (c) {
+	case 1:
+		int a = 10;
+		return a;
+	default:
+		int b = 20;
+		return b;
+	}
+}
+
+static void test_label_end(int c)
+{
+	if (c == 1)
+		goto end1;
+	if (c == 2)
+		goto end2;
+end1:
+end2:
+}
+
+static void test_case_end(int c)
+{
+	switch (c) {
+	case 0:
+	case 1:
+	}
+	switch (c) {
+	default:
+	}
+}
+
+static void test_label_static_assert(void)
+{
+	goto lbl2;
+lbl2:
+	static_assert(1, "");
+}
+
+static int test_typedef_shadow_label(int c)
+{
+	if (c)
+		goto T_shadow;
+	return 0;
+T_shadow:
+	int v = 1;
+	return v;
+}
+
+/*
+ * check-name: c23-labels
+ * check-command: sparse -std=c23 -pedantic -Wno-decl $file
+ */