BINDGEN_EXTRA_CLANG_ARGS for command line mode issue-1723

Author: smurfd

src/lib.rs

@@ -1435,8 +1435,8 @@ impl Builder {
         self
     }
 
-    /// Generate the Rust bindings using the options built up thus far.
-    pub fn generate(mut self) -> Result<Bindings, ()> {
+    /// Generate the Rust bindings options
+    pub fn generate_options(&mut self) -> &Self {
         // Add any extra arguments from the environment to the clang command line.
         if let Some(extra_clang_args) =
             get_target_dependent_env_var("BINDGEN_EXTRA_CLANG_ARGS")
@@ -1451,7 +1451,7 @@ impl Builder {
 
         // Transform input headers to arguments on the clang command line.
         self.options.input_header = self.input_headers.pop();
-        self.options.extra_input_headers = self.input_headers;
+        self.options.extra_input_headers = self.input_headers.to_vec();
         self.options.clang_args.extend(
             self.options.extra_input_headers.iter().flat_map(|header| {
                 iter::once("-include".into())
@@ -1466,7 +1466,12 @@ impl Builder {
                     clang::UnsavedFile::new(&name, &contents)
                 }),
         );
+        self
+    }
 
+    /// Generate the Rust bindings using the options built up thus far.
+    pub fn generate(mut self) -> Result<Bindings, ()> {
+        self.generate_options();
         Bindings::generate(self.options)
     }
 
@@ -1475,7 +1480,7 @@ impl Builder {
     /// This is useful when debugging bindgen, using C-Reduce, or when filing
     /// issues. The resulting file will be named something like `__bindgen.i` or
     /// `__bindgen.ii`
-    pub fn dump_preprocessed_input(&self) -> io::Result<()> {
+    pub fn dump_preprocessed_input(&mut self) -> io::Result<()> {
         let clang =
             clang_sys::support::Clang::find(None, &[]).ok_or_else(|| {
                 io::Error::new(
@@ -1543,6 +1548,7 @@ impl Builder {
             "__bindgen.i"
         })?;
         io::copy(&mut preprocessed, &mut file)?;
+        self.generate_options();
 
         if child.wait()?.success() {
             Ok(())
@@ -2189,39 +2195,8 @@ fn find_effective_target(clang_args: &[String]) -> (String, bool) {
 }
 
 impl Bindings {
-    /// Generate bindings for the given options.
-    pub(crate) fn generate(
-        mut options: BindgenOptions,
-    ) -> Result<Bindings, ()> {
-        ensure_libclang_is_loaded();
-
-        #[cfg(feature = "runtime")]
-        debug!(
-            "Generating bindings, libclang at {}",
-            clang_sys::get_library().unwrap().path().display()
-        );
-        #[cfg(not(feature = "runtime"))]
-        debug!("Generating bindings, libclang linked");
-
-        options.build();
-
-        let (effective_target, explicit_target) =
-            find_effective_target(&options.clang_args);
-
-        let is_host_build =
-            rust_to_clang_target(HOST_TARGET) == effective_target;
-
-        // NOTE: The is_host_build check wouldn't be sound normally in some
-        // cases if we were to call a binary (if you have a 32-bit clang and are
-        // building on a 64-bit system for example).  But since we rely on
-        // opening libclang.so, it has to be the same architecture and thus the
-        // check is fine.
-        if !explicit_target && !is_host_build {
-            options
-                .clang_args
-                .insert(0, format!("--target={}", effective_target));
-        };
-
+    /// Common part of generate()
+    fn generate_common(options: &mut BindgenOptions) {
         fn detect_include_paths(options: &mut BindgenOptions) {
             if !options.detect_include_paths {
                 return;
@@ -2298,8 +2273,43 @@ impl Bindings {
                 }
             }
         }
+        detect_include_paths(options);
+    }
+
+    /// Generate bindings for the given options.
+    pub(crate) fn generate(
+        mut options: BindgenOptions,
+    ) -> Result<Bindings, ()> {
+        ensure_libclang_is_loaded();
+
+        #[cfg(feature = "runtime")]
+        debug!(
+            "Generating bindings, libclang at {}",
+            clang_sys::get_library().unwrap().path().display()
+        );
+        #[cfg(not(feature = "runtime"))]
+        debug!("Generating bindings, libclang linked");
+
+        options.build();
+
+        let (effective_target, explicit_target) =
+            find_effective_target(&options.clang_args);
+
+        let is_host_build =
+            rust_to_clang_target(HOST_TARGET) == effective_target;
+
+        // NOTE: The is_host_build check wouldn't be sound normally in some
+        // cases if we were to call a binary (if you have a 32-bit clang and are
+        // building on a 64-bit system for example).  But since we rely on
+        // opening libclang.so, it has to be the same architecture and thus the
+        // check is fine.
+        if !explicit_target && !is_host_build {
+            options
+                .clang_args
+                .insert(0, format!("--target={}", effective_target));
+        };
 
-        detect_include_paths(&mut options);
+        Bindings::generate_common(&mut options);
 
         #[cfg(unix)]
         fn can_read(perms: &std::fs::Permissions) -> bool {