Don't require a Box wrapper on Bindings::write()

The function in question doesn't store the `dyn Write` trait object
anywhere, allowing us to pass a plain `&mut dyn Write` (which is also
implemented for `&mut Box<dyn Write>` allowing the existing CLI parser
to operate normally).

This in turn no longer requires users of `bindgen` to wrap their
`&mut File` or `&mut Vec<u8>` in a moved `Box` just to be able to give
temporary mutable access to the `write() function`.

Author: MarijnS95

bindgen-cli/main.rs

@@ -29,7 +29,7 @@ pub fn main() {
     env_logger::init();
 
     match builder_from_flags(env::args()) {
-        Ok((builder, output, verbose)) => {
+        Ok((builder, mut output, verbose)) => {
             #[cfg(feature = "logging")]
             clang_version_check();
 
@@ -50,7 +50,7 @@ pub fn main() {
 
             let _ = std::panic::take_hook();
 
-            bindings.write(output).expect("Unable to write output");
+            bindings.write(&mut output).expect("Unable to write output");
         }
         Err(error) => {
             eprintln!("{error}");

bindgen-tests/tests/parse_callbacks/add_derives_callback/mod.rs

@@ -19,25 +19,11 @@ mod tests {
         }
     }
 
-    struct WriteAdapter<'a>(&'a mut Vec<u8>);
-
-    impl std::io::Write for WriteAdapter<'_> {
-        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-            self.0.extend_from_slice(buf);
-            Ok(buf.len())
-        }
-        fn flush(&mut self) -> std::io::Result<()> {
-            Ok(())
-        }
-    }
-
     fn write_bindings_to_string(bindings: &Bindings) -> String {
         let mut output = Vec::<u8>::new();
-        bindings
-            .write(Box::new(WriteAdapter(&mut output)))
-            .unwrap_or_else(|e| {
-                panic!("Failed to write generated bindings: {e}")
-            });
+        bindings.write(&mut output).unwrap_or_else(|e| {
+            panic!("Failed to write generated bindings: {e}")
+        });
         String::from_utf8(output).unwrap_or_else(|e| {
             panic!("Failed to convert generated bindings to string: {e}")
         })
@@ -74,8 +60,8 @@ mod tests {
         let output = write_bindings_to_string(&bindings);
         let output_without_spaces = output.replace(' ', "");
         assert!(
-            output_without_spaces.contains("#[derive(Debug)]") &&
-                !output_without_spaces.contains("#[derive(Debug,Debug)]"),
+            output_without_spaces.contains("#[derive(Debug)]")
+                && !output_without_spaces.contains("#[derive(Debug,Debug)]"),
             "Unexpected bindgen output:\n{}",
             output.as_str()
         );

bindgen/lib.rs

@@ -87,10 +87,10 @@ const DEFAULT_NON_EXTERN_FNS_SUFFIX: &str = "__extern";
 
 fn file_is_cpp(name_file: &str) -> bool {
     Path::new(name_file).extension().is_some_and(|ext| {
-        ext.eq_ignore_ascii_case("hpp") ||
-            ext.eq_ignore_ascii_case("hxx") ||
-            ext.eq_ignore_ascii_case("hh") ||
-            ext.eq_ignore_ascii_case("h++")
+        ext.eq_ignore_ascii_case("hpp")
+            || ext.eq_ignore_ascii_case("hxx")
+            || ext.eq_ignore_ascii_case("hh")
+            || ext.eq_ignore_ascii_case("h++")
     })
 }
 
@@ -347,10 +347,10 @@ impl Builder {
             .clang_args
             .iter()
             .filter(|arg| {
-                !arg.starts_with("-MMD") &&
-                    !arg.starts_with("-MD") &&
-                    !arg.starts_with("--write-user-dependencies") &&
-                    !arg.starts_with("--user-dependencies")
+                !arg.starts_with("-MMD")
+                    && !arg.starts_with("-MD")
+                    && !arg.starts_with("--write-user-dependencies")
+                    && !arg.starts_with("--user-dependencies")
             })
             .cloned()
             .collect::<Vec<_>>();
@@ -819,8 +819,8 @@ impl Bindings {
                             return false;
                         }
 
-                        if arg.starts_with("-I") ||
-                            arg.starts_with("--include-directory=")
+                        if arg.starts_with("-I")
+                            || arg.starts_with("--include-directory=")
                         {
                             return false;
                         }
@@ -845,8 +845,8 @@ impl Bindings {
             debug!("Found clang: {clang:?}");
 
             // Whether we are working with C or C++ inputs.
-            let is_cpp = args_are_cpp(&options.clang_args) ||
-                options.input_headers.iter().any(|h| file_is_cpp(h));
+            let is_cpp = args_are_cpp(&options.clang_args)
+                || options.input_headers.iter().any(|h| file_is_cpp(h));
 
             let search_paths = if is_cpp {
                 clang.cpp_search_paths
@@ -927,17 +927,17 @@ impl Bindings {
 
     /// Write these bindings as source text to a file.
     pub fn write_to_file<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
-        let file = OpenOptions::new()
+        let mut file = OpenOptions::new()
             .write(true)
             .truncate(true)
             .create(true)
             .open(path.as_ref())?;
-        self.write(Box::new(file))?;
+        self.write(&mut file)?;
         Ok(())
     }
 
     /// Write these bindings as source text to the given `Write`able.
-    pub fn write<'a>(&self, mut writer: Box<dyn Write + 'a>) -> io::Result<()> {
+    pub fn write(&self, writer: &mut dyn Write) -> io::Result<()> {
         const NL: &str = if cfg!(windows) { "\r\n" } else { "\n" };
 
         if !self.options.disable_header_comment {
@@ -1090,7 +1090,7 @@ fn rustfmt_non_fatal_error_diagnostic(msg: &str, _options: &BindgenOptions) {
 impl std::fmt::Display for Bindings {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut bytes = vec![];
-        self.write(Box::new(&mut bytes) as Box<dyn Write>)
+        self.write(&mut bytes)
             .expect("writing to a vec cannot fail");
         f.write_str(
             std::str::from_utf8(&bytes)

bindgen/options/cli.rs

@@ -797,8 +797,8 @@ where
         }
 
         fn add_derives(&self, info: &DeriveInfo<'_>) -> Vec<String> {
-            if self.kind.map_or(true, |kind| kind == info.kind) &&
-                self.regex_set.matches(info.name)
+            if self.kind.map_or(true, |kind| kind == info.kind)
+                && self.regex_set.matches(info.name)
             {
                 return self.derives.clone();
             }
@@ -837,8 +837,8 @@ where
         }
 
         fn add_attributes(&self, info: &AttributeInfo<'_>) -> Vec<String> {
-            if self.kind.map_or(true, |kind| kind == info.kind) &&
-                self.regex_set.matches(info.name)
+            if self.kind.map_or(true, |kind| kind == info.kind)
+                && self.regex_set.matches(info.name)
             {
                 return self.attributes.clone();
             }