[PATCH 46/73] c23: Support unnamed parameters in function definitions

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

Allow function definitions to omit parameter names in C23 mode per ISO
C23 6.9.1 while rejecting unnamed parameters as an error in pre-C23
standards:
- Check for missing type specifiers before skipping local scope binding
  for unnamed parameters.
- Preserve argument side effects when inlining calls to functions with
  unnamed parameters without triggering unreplaced-symbol warnings.
- Advance parameter slot indices across unnamed parameters during
  linearization so subsequent named parameters keep their ABI slot index.
- Reject qualified, named, or multi-parameter uses of 'void'.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 inline.c                                 |  6 ++-
 linearize.c                              |  8 ++--
 parse.c                                  | 27 +++++++++-----
 validation/c23-unnamed-params-error.c    | 27 ++++++++++++++
 validation/c23-unnamed-params-pedantic.c | 12 ++++++
 validation/c23-unnamed-params.c          | 47 ++++++++++++++++++++++++
 validation/linear/c23-unnamed-params.c   | 27 ++++++++++++++
 7 files changed, 141 insertions(+), 13 deletions(-)
 create mode 100644 validation/c23-unnamed-params-error.c
 create mode 100644 validation/c23-unnamed-params-pedantic.c
 create mode 100644 validation/c23-unnamed-params.c
 create mode 100644 validation/linear/c23-unnamed-params.c

diff --git a/inline.c b/inline.c
index d94fba807d19..d3f27952138b 100644
--- a/inline.c
+++ b/inline.c
@@ -631,7 +631,7 @@ int inline_function(struct expression *expr, struct symbol *sym)
 	FOR_EACH_PTR(expr->args, arg) {
 		struct symbol *a = alloc_symbol(arg->pos, SYM_NODE);
 
-		if (name) {
+		if (name && name->ident) {
 			*a = *name;
 			a->bb_target = NULL;
 			a->pseudo = NULL;
@@ -639,6 +639,10 @@ int inline_function(struct expression *expr, struct symbol *sym)
 			add_symbol(&fn_symbol_list, a);
 			a->initializer = arg;
 			add_symbol(&arg_decl, a);
+		} else if (name) {
+			*a = *name;
+			a->initializer = arg;
+			add_symbol(&arg_decl, a);
 		} else {
 			// This may create a node of a node but it will
 			// be resolved later when the corresponding
diff --git a/linearize.c b/linearize.c
index 422cee820ddb..4179aea03af1 100644
--- a/linearize.c
+++ b/linearize.c
@@ -2607,12 +2607,14 @@ static struct entrypoint *linearize_fn(struct symbol *sym, struct symbol *base_t
 	add_one_insn(ep, entry);
 	ep->entry = entry;
 
-	concat_symbol_list(base_type->arguments, &ep->syms);
-
 	/* FIXME!! We should do something else about varargs.. */
 	i = 0;
 	FOR_EACH_PTR(base_type->arguments, arg) {
-		linearize_argument(ep, arg, ++i);
+		++i;
+		if (!arg->ident)
+			continue;
+		add_symbol(&ep->syms, arg);
+		linearize_argument(ep, arg, i);
 	} END_FOR_EACH_PTR(arg);
 
 	result = linearize_fn_statement(ep, stmt);
diff --git a/parse.c b/parse.c
index 5e526b0cc840..6af5bfba2392 100644
--- a/parse.c
+++ b/parse.c
@@ -1702,6 +1702,8 @@ static struct token *declaration_specifiers(struct token *token, struct decl_sta
 				specifier_conflict(token->pos,
 						   seen & s->op->test,
 						   token->ident);
+				ctx->ctype.base_type = &bad_ctype;
+				seen |= Set_S;
 				break;
 			}
 			seen |= s->op->set;
@@ -2772,10 +2774,12 @@ static struct token *parameter_type_list(struct token *token, struct symbol *fn)
 		sym = alloc_symbol(token->pos, SYM_NODE);
 		token = parameter_declaration(token, sym);
 		if (sym->ctype.base_type == &void_ctype) {
-			/* Special case: (void) */
-			if (!*list && !sym->ident)
+			/* Special case: sole unnamed unqualified (void) */
+			if (!*list && !sym->ident && match_op(token, ')') &&
+			    !(sym->ctype.modifiers & (MOD_QUALIFIER | MOD_STORAGE | MOD_ATOMIC)))
 				break;
-			warning(token->pos, "void parameter");
+			sparse_error(sym->pos, "'void' must be the only parameter");
+			sym->ctype.base_type = &bad_ctype;
 		}
 		add_symbol(list, sym);
 		if (!match_op(token, ','))
@@ -2917,18 +2921,23 @@ struct token *initializer(struct expression **tree, struct token *token)
 
 static void declare_argument(struct symbol *sym, struct symbol *fn)
 {
-	if (!sym->ident) {
-		sparse_error(sym->pos, "no identifier for function argument");
-		return;
-	}
 	if (sym->ctype.base_type == &incomplete_ctype) {
 		sym->ctype.base_type = &int_ctype;
 
 		if (Wimplicit_int) {
-			sparse_error(sym->pos, "missing type declaration for parameter '%s'",
-				show_ident(sym->ident));
+			if (sym->ident)
+				sparse_error(sym->pos, "missing type declaration for parameter '%s'",
+					show_ident(sym->ident));
+			else
+				sparse_error(sym->pos, "missing type declaration for parameter");
 		}
 	}
+	if (!sym->ident) {
+		if (standard < STANDARD_C23 && sym->ctype.base_type != &bad_ctype)
+			sparse_error(sym->pos,
+				     "omitting parameter name in function definition is a C23 feature");
+		return;
+	}
 	bind_symbol(sym, sym->ident, NS_SYMBOL);
 }
 
diff --git a/validation/c23-unnamed-params-error.c b/validation/c23-unnamed-params-error.c
new file mode 100644
index 000000000000..6630f96b53b5
--- /dev/null
+++ b/validation/c23-unnamed-params-error.c
@@ -0,0 +1,27 @@
+static void f_implicit(const)
+{
+}
+
+static void f_void1(void, int)
+{
+}
+
+static void f_void2(int, void)
+{
+}
+
+static void f_cvoid(const void)
+{
+}
+
+/*
+ * check-name: c23-unnamed-params-error
+ * check-command: sparse -std=c23 $file
+ *
+ * check-error-start
+c23-unnamed-params-error.c:1:24: error: missing type declaration for parameter
+c23-unnamed-params-error.c:5:21: error: 'void' must be the only parameter
+c23-unnamed-params-error.c:9:26: error: 'void' must be the only parameter
+c23-unnamed-params-error.c:13:21: error: 'void' must be the only parameter
+ * check-error-end
+ */
diff --git a/validation/c23-unnamed-params-pedantic.c b/validation/c23-unnamed-params-pedantic.c
new file mode 100644
index 000000000000..aa2a204628fe
--- /dev/null
+++ b/validation/c23-unnamed-params-pedantic.c
@@ -0,0 +1,12 @@
+static void f1(int)
+{
+}
+
+/*
+ * check-name: c23-unnamed-params-pedantic
+ * check-command: sparse -std=c11 $file
+ *
+ * check-error-start
+c23-unnamed-params-pedantic.c:1:16: error: omitting parameter name in function definition is a C23 feature
+ * check-error-end
+ */
diff --git a/validation/c23-unnamed-params.c b/validation/c23-unnamed-params.c
new file mode 100644
index 000000000000..ddecb8e9e0b9
--- /dev/null
+++ b/validation/c23-unnamed-params.c
@@ -0,0 +1,47 @@
+static void f1(int)
+{
+}
+
+static void f2(int, double)
+{
+}
+
+static int f3(int a, double, int b)
+{
+	return a + b;
+}
+
+static void f4(void (*)(int))
+{
+}
+
+static void f5(int [static 4], const int)
+{
+}
+
+static inline int inl_unnamed(int a, int, int b)
+{
+	return a + b;
+}
+
+static int bump(int *cnt)
+{
+	return (*cnt)++;
+}
+
+static int test_calls(void)
+{
+	int arr[4] = { 1, 2, 3, 4 };
+	int cnt = 0;
+
+	f1(1);
+	f2(2, 3.0);
+	f4(f1);
+	f5(arr, 7);
+	return f3(10, 0.5, 20) + inl_unnamed(1, bump(&cnt), 2) + cnt;
+}
+
+/*
+ * check-name: c23-unnamed-params
+ * check-command: sparse -std=c23 -pedantic $file
+ */
diff --git a/validation/linear/c23-unnamed-params.c b/validation/linear/c23-unnamed-params.c
new file mode 100644
index 000000000000..add966d3ea71
--- /dev/null
+++ b/validation/linear/c23-unnamed-params.c
@@ -0,0 +1,27 @@
+int f3(int a, double, int b);
+int f3(int a, double, int b)
+{
+	return a + b;
+}
+
+static inline int inl(int a, int, int b)
+{
+	return a + b;
+}
+
+extern int side_effect(void);
+
+int caller(void);
+int caller(void)
+{
+	return inl(10, side_effect(), 20);
+}
+
+/*
+ * check-name: linear-c23-unnamed-params
+ * check-command: test-linearize -m64 -std=c23 $file
+ *
+ * check-output-ignore
+ * check-output-contains: add\\.32 *%r[0-9]* <- %arg1, %arg3
+ * check-output-contains: call\\.32 *%r[0-9]* <- side_effect
+ */