fixup: use methods to compose callbacks

Author: pvdrz

bindgen/codegen/mod.rs

@@ -2112,7 +2112,9 @@ impl CodeGenerator for CompInfo {
 
         // The custom derives callback may return a list of derive attributes;
         // add them to the end of the list.
-        let custom_derives = ctx.options().parse_callbacks.iter().flat_map(|cb| cb.add_derives(&canonical_name)).collect::<Vec<String>>();
+        let custom_derives = ctx
+            .options()
+            .all_callbacks(|cb| cb.add_derives(&canonical_name));
         // In most cases this will be a no-op, since custom_derives will be empty.
         derives.extend(custom_derives.iter().map(|s| s.as_str()));
 
@@ -3149,7 +3151,8 @@ impl CodeGenerator for Enum {
 
             // The custom derives callback may return a list of derive attributes;
             // add them to the end of the list.
-            let custom_derives = ctx.options().parse_callbacks.iter().flat_map(|cb| cb.add_derives(&name)).collect::<Vec<String>>();
+            let custom_derives =
+                ctx.options().all_callbacks(|cb| cb.add_derives(&name));
             // In most cases this will be a no-op, since custom_derives will be empty.
             derives.extend(custom_derives.iter().map(|s| s.as_str()));
 

bindgen/ir/context.rs

@@ -19,7 +19,6 @@ use super::module::{Module, ModuleKind};
 use super::template::{TemplateInstantiation, TemplateParameters};
 use super::traversal::{self, Edge, ItemTraversal};
 use super::ty::{FloatKind, Type, TypeKind};
-use crate::callbacks::ParseCallbacks;
 use crate::clang::{self, Cursor};
 use crate::parse::ClangItemParser;
 use crate::BindgenOptions;
@@ -619,14 +618,9 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         )
     }
 
-    /// Get the user-provided callbacks by reference, if any.
-    pub fn parse_callbacks(&self) -> impl Iterator<Item = &dyn ParseCallbacks> {
-        self.options().parse_callbacks.iter().map(|cb| cb.as_ref())
-    }
-
     /// Add another path to the set of included files.
     pub fn include_file(&mut self, filename: String) {
-        for cb in self.parse_callbacks() {
+        for cb in &self.options().parse_callbacks {
             cb.include_file(&filename);
         }
         self.deps.insert(filename);
@@ -2251,7 +2245,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                                 Some(CanDerive::No)
                             }
                         } else {
-                            self.options.parse_callbacks.iter().find_map(|cb| {
+                            self.options.last_callback(|cb| {
                                 cb.blocklisted_type_implements_trait(
                                     name,
                                     derive_trait,

bindgen/ir/enum_ty.rs

@@ -102,8 +102,8 @@ impl Enum {
                     let name = cursor.spelling();
                     let annotations = Annotations::new(&cursor);
                     let custom_behavior = ctx
-                        .parse_callbacks()
-                        .find_map(|callbacks| {
+                        .options()
+                        .last_callback(|callbacks| {
                             callbacks
                                 .enum_variant_behavior(type_name, &name, val)
                         })
@@ -119,8 +119,8 @@ impl Enum {
                         });
 
                     let new_name = ctx
-                        .parse_callbacks()
-                        .find_map(|callbacks| {
+                        .options()
+                        .last_callback(|callbacks| {
                             callbacks.enum_variant_name(type_name, &name, val)
                         })
                         .or_else(|| {

bindgen/ir/function.rs

@@ -665,8 +665,8 @@ impl ClangSubItemParser for Function {
             name.push_str("_destructor");
         }
         if let Some(nm) = context
-            .parse_callbacks()
-            .find_map(|callbacks| callbacks.generated_name_override(&name))
+            .options()
+            .last_callback(|callbacks| callbacks.generated_name_override(&name))
         {
             name = nm;
         }

bindgen/ir/item.rs

@@ -932,8 +932,8 @@ impl Item {
         let name = names.join("_");
 
         let name = if opt.user_mangled == UserMangled::Yes {
-            ctx.parse_callbacks()
-                .find_map(|callbacks| callbacks.item_name(&name))
+            ctx.options()
+                .last_callback(|callbacks| callbacks.item_name(&name))
                 .unwrap_or(name)
         } else {
             name

bindgen/ir/var.rs

@@ -182,7 +182,7 @@ impl ClangSubItemParser for Var {
         use clang_sys::*;
         match cursor.kind() {
             CXCursor_MacroDefinition => {
-                for callbacks in ctx.parse_callbacks() {
+                for callbacks in &ctx.options().parse_callbacks {
                     match callbacks.will_parse_macro(&cursor.spelling()) {
                         MacroParsingBehavior::Ignore => {
                             return Err(ParseError::Continue);
@@ -191,7 +191,7 @@ impl ClangSubItemParser for Var {
                     }
 
                     if cursor.is_macro_function_like() {
-                        handle_function_macro(&cursor, callbacks);
+                        handle_function_macro(&cursor, callbacks.as_ref());
                         // We handled the macro, skip macro processing below.
                         return Err(ParseError::Continue);
                     }
@@ -249,15 +249,15 @@ impl ClangSubItemParser for Var {
                             true,
                             ctx,
                         );
-                        for callbacks in ctx.parse_callbacks() {
+                        for callbacks in &ctx.options().parse_callbacks {
                             callbacks.str_macro(&name, &val);
                         }
                         (TypeKind::Pointer(char_ty), VarType::String(val))
                     }
                     EvalResult::Int(Wrapping(value)) => {
                         let kind = ctx
-                            .parse_callbacks()
-                            .find_map(|c| c.int_macro(&name, value))
+                            .options()
+                            .last_callback(|c| c.int_macro(&name, value))
                             .unwrap_or_else(|| {
                                 default_macro_constant_type(ctx, value)
                             });

bindgen/lib.rs

@@ -2146,9 +2146,6 @@ impl BindgenOptions {
         for regex_set in &mut regex_sets {
             regex_set.build(record_matches);
         }
-
-        // Reverse parse callbacks to have a last-to-first priority.
-        self.parse_callbacks.reverse();
     }
 
     /// Update rust target version
@@ -2163,6 +2160,26 @@ impl BindgenOptions {
     pub fn rust_features(&self) -> RustFeatures {
         self.rust_features
     }
+
+    fn last_callback<T>(
+        &self,
+        f: impl Fn(&dyn crate::callbacks::ParseCallbacks) -> Option<T>,
+    ) -> Option<T> {
+        self.parse_callbacks
+            .iter()
+            .filter_map(|cb| f(cb.as_ref()))
+            .last()
+    }
+
+    fn all_callbacks<T>(
+        &self,
+        f: impl Fn(&dyn crate::callbacks::ParseCallbacks) -> Vec<T>,
+    ) -> Vec<T> {
+        self.parse_callbacks
+            .iter()
+            .flat_map(|cb| f(cb.as_ref()))
+            .collect()
+    }
 }
 
 impl Default for BindgenOptions {