Add: Support #[deprecated] attribute

Cargo.toml

@@ -26,7 +26,7 @@ serde = { version = "1.0.103", default-features = false, features = ["derive"] }
 serde_json = "1.0"
 tempfile = "3"
 toml = "0.5"
-proc-macro2 = "1"
+proc-macro2 = "1.0.60"
 quote = "1"
 heck = "0.4"
 

src/bindgen/cdecl.rs

@@ -7,6 +7,7 @@ use std::io::Write;
 use crate::bindgen::config::Layout;
 use crate::bindgen::declarationtyperesolver::DeclarationType;
 use crate::bindgen::ir::{ConstExpr, Function, GenericArgument, Type};
+use crate::bindgen::utilities::create_deprecate_attribute;
 use crate::bindgen::writer::{ListType, SourceWriter};
 use crate::bindgen::{Config, Language};
 
@@ -40,6 +41,7 @@ struct CDecl {
     type_generic_args: Vec<GenericArgument>,
     declarators: Vec<CDeclarator>,
     type_ctype: Option<DeclarationType>,
+    deprecated: Option<String>,
 }
 
 impl CDecl {
@@ -50,6 +52,7 @@ impl CDecl {
             type_generic_args: Vec::new(),
             declarators: Vec::new(),
             type_ctype: None,
+            deprecated: None,
         }
     }
 
@@ -99,6 +102,7 @@ impl CDecl {
             layout,
             never_return: f.never_return,
         });
+        self.deprecated = f.annotations.deprecated.clone();
         self.build_type(&f.ret, false, config);
     }
 
@@ -189,7 +193,21 @@ impl CDecl {
     }
 
     fn write<F: Write>(&self, out: &mut SourceWriter<F>, ident: Option<&str>, config: &Config) {
-        // Write the type-specifier and type-qualifier first
+        // Write deprecated attribute
+        if config.language != Language::Cython {
+            if let Some(ref deprecated) = self.deprecated {
+                if config.language == Language::Cxx {
+                    writeln!(out, "{}", create_deprecate_attribute(deprecated));
+                } else {
+                    out.write("#if __STDC_VERSION__ >= 202311L");
+                    out.new_line();
+                    writeln!(out, "{}", create_deprecate_attribute(deprecated));
+                    out.write("#endif // __STDC_VERSION__ >= 202311L");
+                    out.new_line();
+                }
+            }
+        }
+        // Write the type-specifier and type-qualifier
         if !self.type_qualifers.is_empty() {
             write!(out, "{} ", self.type_qualifers);
         }

src/bindgen/ir/annotation.rs

@@ -35,13 +35,15 @@ pub enum AnnotationValue {
 pub struct AnnotationSet {
     annotations: HashMap<String, AnnotationValue>,
     pub must_use: bool,
+    pub deprecated: Option<String>,
 }
 
 impl AnnotationSet {
     pub fn new() -> AnnotationSet {
         AnnotationSet {
             annotations: HashMap::new(),
             must_use: false,
+            deprecated: None,
         }
     }
 
@@ -68,6 +70,36 @@ impl AnnotationSet {
             .collect();
 
         let must_use = attrs.has_attr_word("must_use");
+        let deprecated = if let Some(note) = attrs.attr_name_value_lookup("deprecated") {
+            Some(note)
+        } else if attrs.has_attr_word("deprecated") {
+            Some("".to_string())
+        } else if let Some(attr) = attrs.iter().find(|attr| {
+            if let Ok(syn::Meta::List(list)) = attr.parse_meta() {
+                list.path.is_ident("deprecated")
+            } else {
+                false
+            }
+        }) {
+            let args: syn::punctuated::Punctuated<syn::MetaNameValue, Token![,]> = attr
+                .parse_args_with(syn::punctuated::Punctuated::parse_terminated)
+                .map_err(|e| format!("Couldn't parse deprecated attribute: {}", e.to_string()))?;
+            let Some(lit) = args
+                .iter()
+                .find(|arg| arg.path.is_ident("note"))
+                .map(|arg| &arg.lit)
+            else {
+                return Err("Couldn't parse deprecated attribute: no `note` field".to_string());
+            };
+
+            if let syn::Lit::Str(lit) = lit {
+                Some(lit.value())
+            } else {
+                return Err("deprecated attribute must be a string".to_string());
+            }
+        } else {
+            None
+        };
 
         let mut annotations = HashMap::new();
 
@@ -118,6 +150,7 @@ impl AnnotationSet {
         Ok(AnnotationSet {
             annotations,
             must_use,
+            deprecated,
         })
     }
 

src/bindgen/ir/enumeration.rs

@@ -19,6 +19,7 @@ use crate::bindgen::mangle;
 use crate::bindgen::monomorph::Monomorphs;
 use crate::bindgen::rename::{IdentifierType, RenameRule};
 use crate::bindgen::reserved;
+use crate::bindgen::utilities::create_deprecate_attribute;
 use crate::bindgen::writer::{ListType, Source, SourceWriter};
 
 #[allow(clippy::large_enum_variant)]
@@ -769,6 +770,22 @@ impl Enum {
                         out.write("typedef ");
                     }
                     out.write("enum");
+                    if let Some(ref note) = self.annotations.deprecated {
+                        if config.cpp_compatible_c() {
+                            out.write("#if defined(__cplusplus) || __STDC_VERSION__ >= 202311L");
+                        } else {
+                            out.write("#if __STDC_VERSION__ >= 201112L");
+                        }
+                        out.new_line();
+
+                        write!(out, " {}", create_deprecate_attribute(note));
+                        if config.cpp_compatible_c() {
+                            out.write("#endif // defined(__cplusplus) || __STDC_VERSION__ >= 202311L");
+                        } else {
+                            out.write("#endif // __STDC_VERSION__ >= 201112L");
+                        }
+                        out.new_line();
+                    }
                     if config.style.generate_tag() {
                         write!(out, " {}", tag_name);
                     }
@@ -781,6 +798,10 @@ impl Enum {
                     out.write("enum");
                 }
 
+                if let Some(ref note) = self.annotations.deprecated {
+                    write!(out, " {}", create_deprecate_attribute(note));
+                }
+
                 if self.annotations.must_use(config) {
                     if let Some(ref anno) = config.enumeration.must_use {
                         write!(out, " {}", anno)

src/bindgen/utilities.rs

@@ -293,3 +293,12 @@ fn split_doc_attr(input: &str) -> Vec<String> {
         .map(|s| s.trim_end().to_string())
         .collect()
 }
+
+pub fn create_deprecate_attribute(deprecated: &String) -> String {
+    if deprecated.is_empty() {
+        "[[deprecated]]".to_string()
+    } else {
+        // FIXME: I used {:?} to escape the string, but there should be much better way
+        format!("[[deprecated({:?})]]", deprecated)
+    }
+}

tests/expectations/deprecated.both.c

@@ -0,0 +1,40 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum DeprecatedEnum {
+  A = 0,
+};
+typedef int32_t DeprecatedEnum;
+
+typedef struct DeprecatedStruct {
+  int32_t a;
+} DeprecatedStruct;
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_without_note(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_without_bracket(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note_and_since(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This quote \" requires to be quoted, and this [\n] requires to be escaped")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note_which_requires_to_be_escaped(void);
+
+void dummy(DeprecatedEnum a, struct DeprecatedStruct b);

tests/expectations/deprecated.both.compat.c

@@ -0,0 +1,54 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum DeprecatedEnum
+#ifdef __cplusplus
+  : int32_t
+#endif // __cplusplus
+ {
+  A = 0,
+};
+#ifndef __cplusplus
+typedef int32_t DeprecatedEnum;
+#endif // __cplusplus
+
+typedef struct DeprecatedStruct {
+  int32_t a;
+} DeprecatedStruct;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_without_note(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_without_bracket(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note_and_since(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This quote \" requires to be quoted, and this [\n] requires to be escaped")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note_which_requires_to_be_escaped(void);
+
+void dummy(DeprecatedEnum a, struct DeprecatedStruct b);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

tests/expectations/deprecated.c

@@ -0,0 +1,40 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum DeprecatedEnum {
+  A = 0,
+};
+typedef int32_t DeprecatedEnum;
+
+typedef struct {
+  int32_t a;
+} DeprecatedStruct;
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_without_note(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_without_bracket(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note_and_since(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This quote \" requires to be quoted, and this [\n] requires to be escaped")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note_which_requires_to_be_escaped(void);
+
+void dummy(DeprecatedEnum a, DeprecatedStruct b);

tests/expectations/deprecated.compat.c

@@ -0,0 +1,54 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum DeprecatedEnum
+#ifdef __cplusplus
+  : int32_t
+#endif // __cplusplus
+ {
+  A = 0,
+};
+#ifndef __cplusplus
+typedef int32_t DeprecatedEnum;
+#endif // __cplusplus
+
+typedef struct {
+  int32_t a;
+} DeprecatedStruct;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_without_note(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_without_bracket(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This is a note")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note_and_since(void);
+
+#if __STDC_VERSION__ >= 202311L
+[[deprecated("This quote \" requires to be quoted, and this [\n] requires to be escaped")]]
+#endif // __STDC_VERSION__ >= 202311L
+void deprecated_with_note_which_requires_to_be_escaped(void);
+
+void dummy(DeprecatedEnum a, DeprecatedStruct b);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus