[PATCH 53/73] preprocessor: Add support for __has_c_attribute

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

Support the C23 __has_c_attribute preprocessor operator for testing
support for standard C23 and vendor attributes so that preprocessor
conditionals can probe whether specific attributes are supported before
using them.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 pre-process.c                                 | 66 +++++++++++++++++++
 validation/c23-attributes.c                   |  3 +
 validation/preprocessor/c23-has-c-attribute.c | 60 +++++++++++++++++
 3 files changed, 129 insertions(+)
 create mode 100644 validation/preprocessor/c23-has-c-attribute.c

diff --git a/pre-process.c b/pre-process.c
index a733927c4c14..aac194cf4c01 100644
--- a/pre-process.c
+++ b/pre-process.c
@@ -2364,6 +2364,71 @@ static int handle_nondirective(struct stream *stream, struct token **line, struc
 	return 1;
 }
 
+static bool expand_has_c_attribute(struct token *token, struct arg *args)
+{
+	struct token *arg = args[0].expanded;
+	const char *name;
+	const char *val = "0";
+	char buf[4096];
+
+	if (token_type(arg) != TOKEN_IDENT) {
+		sparse_error(eof_token(arg) ? token->pos : arg->pos,
+			     "identifier expected");
+		return false;
+	}
+
+	if (match_op(arg->next, ':') && match_op(arg->next->next, ':')) {
+		struct token *attr = arg->next->next->next;
+		if (token_type(attr) != TOKEN_IDENT || !eof_token(attr->next)) {
+			sparse_error(eof_token(attr) ? token->pos : attr->pos,
+				     "identifier expected");
+			return false;
+		}
+		if (arg->ident == &gnu_ident || arg->ident == &__gnu___ident) {
+			struct symbol *sym = lookup_symbol(attr->ident, NS_KEYWORD);
+			if (sym && sym->op && sym->op->attribute)
+				val = "1";
+		}
+		token_type(token) = TOKEN_NUMBER;
+		token->number = val;
+		return true;
+	}
+
+	if (!eof_token(arg->next)) {
+		sparse_error(arg->next->pos, "expected ')'");
+		return false;
+	}
+
+	name = show_ident(arg->ident);
+	if (name[0] == '_' && name[1] == '_') {
+		size_t len = strlen(name);
+		if (len > 4 && name[len - 1] == '_' && name[len - 2] == '_') {
+			if (len - 4 < sizeof(buf)) {
+				memcpy(buf, name + 2, len - 4);
+				buf[len - 4] = '\0';
+				name = buf;
+			}
+		}
+	}
+
+	if (!strcmp(name, "deprecated"))
+		val = "201904L";
+	else if (!strcmp(name, "fallthrough"))
+		val = "201910L";
+	else if (!strcmp(name, "nodiscard"))
+		val = "202003L";
+	else if (!strcmp(name, "maybe_unused"))
+		val = "202106L";
+	else if (!strcmp(name, "noreturn") || !strcmp(name, "_Noreturn"))
+		val = "202202L";
+	else if (!strcmp(name, "reproducible") || !strcmp(name, "unsequenced"))
+		val = "202207L";
+
+	token_type(token) = TOKEN_NUMBER;
+	token->number = val;
+	return true;
+}
+
 static bool expand_has_attribute(struct token *token, struct arg *args)
 {
 	struct token *arg = args[0].expanded;
@@ -2528,6 +2593,7 @@ static void init_preprocessor(void)
 		{ "__INCLUDE_LEVEL__", expand_include_level },
 		{ "__has_attribute", NULL, expand_has_attribute },
 		{ "__has_builtin", NULL, expand_has_builtin },
+		{ "__has_c_attribute", NULL, expand_has_c_attribute },
 		{ "__has_extension", NULL, expand_has_extension },
 		{ "__has_feature", NULL, expand_has_feature },
 		{ "__has_include", NULL, NULL },
diff --git a/validation/c23-attributes.c b/validation/c23-attributes.c
index 8b53ce06d0cf..d288574dec1c 100644
--- a/validation/c23-attributes.c
+++ b/validation/c23-attributes.c
@@ -1,3 +1,6 @@
+static_assert(__has_c_attribute(maybe_unused) != 0);
+static_assert(__has_c_attribute(nodiscard) != 0);
+
 [[maybe_unused]] static int unused_var;
 
 [[nodiscard]] static int get_val(void)
diff --git a/validation/preprocessor/c23-has-c-attribute.c b/validation/preprocessor/c23-has-c-attribute.c
new file mode 100644
index 000000000000..583fe98d0b9e
--- /dev/null
+++ b/validation/preprocessor/c23-has-c-attribute.c
@@ -0,0 +1,60 @@
+#if defined(__has_c_attribute)
+int has_macro = 1;
+#endif
+
+#if __has_c_attribute(nodiscard) == 202003L
+int has_nodiscard = __has_c_attribute(nodiscard);
+#endif
+
+#if __has_c_attribute(__maybe_unused__) == 202106L
+int has_maybe_unused = __has_c_attribute(__maybe_unused__);
+#endif
+
+#if __has_c_attribute(deprecated) == 201904L
+int has_deprecated = __has_c_attribute(deprecated);
+#endif
+
+#if __has_c_attribute(fallthrough) == 201910L
+int has_fallthrough = __has_c_attribute(fallthrough);
+#endif
+
+#if __has_c_attribute(noreturn) == 202202L && \
+    __has_c_attribute(_Noreturn) == 202202L
+int has_noreturn = __has_c_attribute(noreturn);
+#endif
+
+#if __has_c_attribute(reproducible) == 202207L && \
+    __has_c_attribute(unsequenced) == 202207L
+long has_reproducible = __has_c_attribute(reproducible);
+#endif
+
+#if !__has_c_attribute(unknown_attr_12345)
+int no_unknown = 1;
+#endif
+
+#if __has_c_attribute(gnu::aligned)
+int has_gnu_aligned = __has_c_attribute(gnu::aligned);
+#endif
+
+#if !__has_c_attribute(nodiscard::invalid)
+int no_scoped_std = 1;
+#endif
+
+/*
+ * check-name: c23-has-c-attribute
+ * check-command: sparse -std=c23 -E $file
+ *
+ * check-output-start
+
+int has_macro = 1;
+int has_nodiscard = 202003L;
+int has_maybe_unused = 202106L;
+int has_deprecated = 201904L;
+int has_fallthrough = 201910L;
+int has_noreturn = 202202L;
+long has_reproducible = 202207L;
+int no_unknown = 1;
+int has_gnu_aligned = 1;
+int no_scoped_std = 1;
+ * check-output-end
+ */