generalize Item to expose documentation and generic params

Author: scovich

src/bindgen/ir/constant.rs

@@ -574,6 +574,10 @@ impl Item for Constant {
         &mut self.annotations
     }
 
+    fn documentation(&self) -> &Documentation {
+        &self.documentation
+    }
+
     fn container(&self) -> ItemContainer {
         ItemContainer::Constant(self.clone())
     }
@@ -589,6 +593,10 @@ impl Item for Constant {
     fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
         self.ty.resolve_declaration_types(resolver);
     }
+
+    fn generic_params(&self) -> Option<&GenericParams> {
+        None
+    }
 }
 
 impl Constant {
@@ -671,7 +679,7 @@ impl Constant {
             value = fields.iter().next().unwrap().1
         }
 
-        language_backend.write_documentation(out, &self.documentation);
+        language_backend.write_documentation(out, self.documentation());
 
         let allow_constexpr = config.constant.allow_constexpr && self.value.can_be_constexpr();
         match config.language {

src/bindgen/ir/enumeration.rs

@@ -318,7 +318,7 @@ impl Enum {
     }
 
     pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
-        if self.generic_params.len() > 0 {
+        if self.is_generic() {
             return;
         }
 
@@ -467,6 +467,10 @@ impl Item for Enum {
         &mut self.annotations
     }
 
+    fn documentation(&self) -> &Documentation {
+        &self.documentation
+    }
+
     fn container(&self) -> ItemContainer {
         ItemContainer::Enum(self.clone())
     }
@@ -492,6 +496,10 @@ impl Item for Enum {
         }
     }
 
+    fn generic_params(&self) -> Option<&GenericParams> {
+        Some(&self.generic_params)
+    }
+
     fn rename_for_config(&mut self, config: &Config) {
         config.export.rename(&mut self.export_name);
 

src/bindgen/ir/global.rs

@@ -5,7 +5,9 @@
 use crate::bindgen::config::Config;
 use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
 use crate::bindgen::dependencies::Dependencies;
-use crate::bindgen::ir::{AnnotationSet, Cfg, Documentation, Item, ItemContainer, Path, Type};
+use crate::bindgen::ir::{
+    AnnotationSet, Cfg, Documentation, GenericParams, Item, ItemContainer, Path, Type,
+};
 use crate::bindgen::library::Library;
 
 #[derive(Debug, Clone)]
@@ -87,6 +89,10 @@ impl Item for Static {
         &mut self.annotations
     }
 
+    fn documentation(&self) -> &Documentation {
+        &self.documentation
+    }
+
     fn container(&self) -> ItemContainer {
         ItemContainer::Static(self.clone())
     }
@@ -99,6 +105,10 @@ impl Item for Static {
         self.ty.resolve_declaration_types(resolver);
     }
 
+    fn generic_params(&self) -> Option<&GenericParams> {
+        None
+    }
+
     fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
         self.ty.add_dependencies(library, out);
     }

src/bindgen/ir/item.rs

@@ -9,8 +9,8 @@ use crate::bindgen::config::Config;
 use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
 use crate::bindgen::dependencies::Dependencies;
 use crate::bindgen::ir::{
-    AnnotationSet, Cfg, Constant, Enum, GenericArgument, OpaqueItem, Path, Static, Struct, Typedef,
-    Union,
+    AnnotationSet, Cfg, Constant, Documentation, Enum, GenericArgument, GenericParams, OpaqueItem,
+    Path, Static, Struct, Typedef, Union,
 };
 use crate::bindgen::library::Library;
 use crate::bindgen::monomorph::Monomorphs;
@@ -27,6 +27,7 @@ pub trait Item {
     fn cfg(&self) -> Option<&Cfg>;
     fn annotations(&self) -> &AnnotationSet;
     fn annotations_mut(&mut self) -> &mut AnnotationSet;
+    fn documentation(&self) -> &Documentation;
 
     fn container(&self) -> ItemContainer;
 
@@ -36,6 +37,13 @@ pub trait Item {
     fn resolve_declaration_types(&mut self, _resolver: &DeclarationTypeResolver) {
         unimplemented!()
     }
+    fn generic_params(&self) -> Option<&GenericParams>;
+
+    fn is_generic(&self) -> bool {
+        self.generic_params()
+            .is_some_and(|params| !params.is_empty())
+    }
+
     fn rename_for_config(&mut self, _config: &Config) {}
     fn add_dependencies(&self, _library: &Library, _out: &mut Dependencies) {}
     fn instantiate_monomorph(

src/bindgen/ir/opaque.rs

@@ -78,6 +78,10 @@ impl Item for OpaqueItem {
         &mut self.annotations
     }
 
+    fn documentation(&self) -> &Documentation {
+        &self.documentation
+    }
+
     fn container(&self) -> ItemContainer {
         ItemContainer::OpaqueItem(self.clone())
     }
@@ -86,6 +90,10 @@ impl Item for OpaqueItem {
         resolver.add_struct(&self.path);
     }
 
+    fn generic_params(&self) -> Option<&GenericParams> {
+        Some(&self.generic_params)
+    }
+
     fn rename_for_config(&mut self, config: &Config) {
         config.export.rename(&mut self.export_name);
     }
@@ -98,11 +106,7 @@ impl Item for OpaqueItem {
         library: &Library,
         out: &mut Monomorphs,
     ) {
-        assert!(
-            !self.generic_params.is_empty(),
-            "{} is not generic",
-            self.path
-        );
+        assert!(self.is_generic(), "{} is not generic", self.path);
 
         // We can be instantiated with less generic params because of default
         // template parameters, or because of empty types that we remove during

src/bindgen/ir/structure.rs

@@ -150,10 +150,6 @@ impl Struct {
         }
     }
 
-    pub fn is_generic(&self) -> bool {
-        self.generic_params.len() > 0
-    }
-
     /// Attempts to convert this struct to a typedef (only works for transparent structs).
     pub fn as_typedef(&self) -> Option<Typedef> {
         if self.is_transparent {
@@ -283,6 +279,10 @@ impl Item for Struct {
         &mut self.annotations
     }
 
+    fn documentation(&self) -> &Documentation {
+        &self.documentation
+    }
+
     fn container(&self) -> ItemContainer {
         ItemContainer::Struct(self.clone())
     }
@@ -301,6 +301,10 @@ impl Item for Struct {
         }
     }
 
+    fn generic_params(&self) -> Option<&GenericParams> {
+        Some(&self.generic_params)
+    }
+
     fn rename_for_config(&mut self, config: &Config) {
         // Rename the name of the struct
         if !(self.has_tag_field && config.language == Language::Cxx) {

src/bindgen/ir/typedef.rs

@@ -102,18 +102,12 @@ impl Typedef {
         }
     }
 
-    pub fn is_generic(&self) -> bool {
-        self.generic_params.len() > 0
-    }
-
     pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
         // Generic structs can instantiate monomorphs only once they've been
         // instantiated. See `instantiate_monomorph` for more details.
-        if self.is_generic() {
-            return;
+        if !self.is_generic() {
+            self.aliased.add_monomorphs(library, out);
         }
-
-        self.aliased.add_monomorphs(library, out);
     }
 
     pub fn mangle_paths(&mut self, monomorphs: &Monomorphs) {
@@ -142,6 +136,10 @@ impl Item for Typedef {
         &mut self.annotations
     }
 
+    fn documentation(&self) -> &Documentation {
+        &self.documentation
+    }
+
     fn container(&self) -> ItemContainer {
         ItemContainer::Typedef(self.clone())
     }
@@ -154,6 +152,10 @@ impl Item for Typedef {
         self.aliased.resolve_declaration_types(resolver);
     }
 
+    fn generic_params(&self) -> Option<&GenericParams> {
+        Some(&self.generic_params)
+    }
+
     fn rename_for_config(&mut self, config: &Config) {
         config.export.rename(&mut self.export_name);
         self.aliased.rename_for_config(config, &self.generic_params);

src/bindgen/ir/union.rs

@@ -100,10 +100,6 @@ impl Union {
         }
     }
 
-    pub fn is_generic(&self) -> bool {
-        self.generic_params.len() > 0
-    }
-
     pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
         // Generic unions can instantiate monomorphs only once they've been
         // instantiated. See `instantiate_monomorph` for more details.
@@ -144,6 +140,10 @@ impl Item for Union {
         &mut self.annotations
     }
 
+    fn documentation(&self) -> &Documentation {
+        &self.documentation
+    }
+
     fn container(&self) -> ItemContainer {
         ItemContainer::Union(self.clone())
     }
@@ -158,6 +158,10 @@ impl Item for Union {
         }
     }
 
+    fn generic_params(&self) -> Option<&GenericParams> {
+        Some(&self.generic_params)
+    }
+
     fn rename_for_config(&mut self, config: &Config) {
         config.export.rename(&mut self.export_name);
         for field in &mut self.fields {

src/bindgen/library.rs

@@ -428,11 +428,11 @@ impl Library {
         }
 
         // Remove structs and opaque items that are generic
-        self.opaque_items.filter(|x| x.generic_params.len() > 0);
-        self.structs.filter(|x| x.generic_params.len() > 0);
-        self.unions.filter(|x| x.generic_params.len() > 0);
-        self.enums.filter(|x| x.generic_params.len() > 0);
-        self.typedefs.filter(|x| x.generic_params.len() > 0);
+        self.opaque_items.filter(|x| x.is_generic());
+        self.structs.filter(|x| x.is_generic());
+        self.unions.filter(|x| x.is_generic());
+        self.enums.filter(|x| x.is_generic());
+        self.typedefs.filter(|x| x.is_generic());
 
         // Mangle the paths that remain
         self.unions

src/bindgen/monomorph.rs

@@ -6,7 +6,7 @@ use std::collections::HashMap;
 use std::mem;
 
 use crate::bindgen::ir::{
-    Enum, GenericArgument, GenericPath, OpaqueItem, Path, Struct, Typedef, Union,
+    Enum, GenericArgument, GenericPath, Item, OpaqueItem, Path, Struct, Typedef, Union,
 };
 use crate::bindgen::library::Library;
 
@@ -34,7 +34,7 @@ impl Monomorphs {
     ) {
         let replacement_path = GenericPath::new(generic.path.clone(), arguments);
 
-        debug_assert!(generic.generic_params.len() > 0);
+        debug_assert!(generic.is_generic());
         debug_assert!(!self.contains(&replacement_path));
 
         self.replacements
@@ -54,7 +54,7 @@ impl Monomorphs {
     ) {
         let replacement_path = GenericPath::new(generic.path.clone(), arguments);
 
-        debug_assert!(generic.generic_params.len() > 0);
+        debug_assert!(generic.is_generic());
         debug_assert!(!self.contains(&replacement_path));
 
         self.replacements
@@ -74,7 +74,7 @@ impl Monomorphs {
     ) {
         let replacement_path = GenericPath::new(generic.path.clone(), arguments);
 
-        debug_assert!(generic.generic_params.len() > 0);
+        debug_assert!(generic.is_generic());
         debug_assert!(!self.contains(&replacement_path));
 
         self.replacements
@@ -93,7 +93,7 @@ impl Monomorphs {
     ) {
         let replacement_path = GenericPath::new(generic.path.clone(), arguments);
 
-        debug_assert!(generic.generic_params.len() > 0);
+        debug_assert!(generic.is_generic());
         debug_assert!(!self.contains(&replacement_path));
 
         self.replacements
@@ -110,7 +110,7 @@ impl Monomorphs {
     ) {
         let replacement_path = GenericPath::new(generic.path.clone(), arguments);
 
-        debug_assert!(generic.generic_params.len() > 0);
+        debug_assert!(generic.is_generic());
         debug_assert!(!self.contains(&replacement_path));
 
         self.replacements