Add: Support #[deprecated] attribute

src/bindgen/ir/annotation.rs

@@ -56,11 +56,11 @@ impl AnnotationSet {
     }
 
     pub(crate) fn deprecated_node(&self, config: &Config) -> Option<String> {
-        if config.language != Language::Cython {
+        if config.language == Language::Cython {
             return None;
         }
 
-        self.deprecated
+        self.deprecated.clone()
     }
 
     pub fn load(attrs: &[syn::Attribute]) -> Result<AnnotationSet, String> {
@@ -78,39 +78,7 @@ impl AnnotationSet {
             .collect();
 
         let must_use = attrs.has_attr_word("must_use");
-        let deprecated = 
-            // #[deprecated(note = "")]
-            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 deprecated = attrs.find_deprecated_note()?;
         let mut annotations = HashMap::new();
 
         // Look at each line for an annotation

src/bindgen/ir/enumeration.rs

@@ -907,7 +907,6 @@ impl Enum {
         }
 
         if let Some(note) = self.annotations.deprecated_node(config) {
-            let note = self.annotations.deprecated.as_ref().unwrap();
             if note.is_empty() {
                 if let Some(ref anno) = config.structure.deprecated {
                     write!(out, " {}", anno);

src/bindgen/utilities.rs

@@ -116,6 +116,47 @@ pub trait SynAttributeHelpers {
             })
     }
 
+    fn find_deprecated_note(&self) -> Result<Option<String>, String> {
+        let attrs = self.attrs();
+        // #[deprecated(note = "")]
+        if let Some(note) = attrs.attr_name_value_lookup("deprecated") {
+            return Ok(Some(note));
+        }
+
+        // #[deprecated]
+        if attrs.has_attr_word("deprecated") {
+            return Ok(Some("".to_string()));
+        }
+
+        // #[deprecated(note = "")]
+        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());
+            };
+
+            return if let syn::Lit::Str(lit) = lit {
+                Ok(Some(lit.value()))
+            } else {
+                Err("deprecated attribute must be a string".to_string())
+            };
+        }
+
+        Ok(None)
+    }
+
     fn is_no_mangle(&self) -> bool {
         self.has_attr_word("no_mangle")
     }