move input headers and clang args fields to options and state

Author: pvdrz

src/ir/context.rs

@@ -523,7 +523,7 @@ impl BindgenContext {
             clang::TranslationUnit::parse(
                 &index,
                 "",
-                &options.clang_args,
+                &state.clang_args,
                 &state.input_unsaved_files,
                 parse_options,
             ).expect("libclang error; possible causes include:
@@ -541,10 +541,10 @@ If you encounter an error missing from this list, please file an issue or a PR!"
 
         // depfiles need to include the explicitly listed headers too
         let mut deps = BTreeSet::default();
-        if let Some(filename) = &options.input_header {
+        if let Some(filename) = &state.input_header {
             deps.insert(filename.clone());
         }
-        deps.extend(options.extra_input_headers.iter().cloned());
+        deps.extend(state.extra_input_headers.iter().cloned());
 
         BindgenContext {
             items: vec![Some(root_module)],

src/lib.rs

@@ -225,7 +225,6 @@ impl Default for CodegenConfig {
 pub struct Builder {
     state: BindgenState,
     options: BindgenOptions,
-    input_headers: Vec<String>,
     // Tuples of unsaved file contents of the form (name, contents).
     input_header_contents: Vec<(String, String)>,
 }
@@ -254,7 +253,7 @@ impl Builder {
     pub fn command_line_flags(&self) -> Vec<String> {
         let mut output_vector: Vec<String> = Vec::new();
 
-        if let Some(header) = self.input_headers.last().cloned() {
+        if let Some(header) = self.options.input_headers.last().cloned() {
             // Positional argument 'header'
             output_vector.push(header);
         }
@@ -602,10 +601,12 @@ impl Builder {
             output_vector.extend(self.options.clang_args.iter().cloned());
         }
 
-        if self.input_headers.len() > 1 {
+        if self.options.input_headers.len() > 1 {
             // To pass more than one header, we need to pass all but the last
             // header via the `-include` clang arg
-            for header in &self.input_headers[..self.input_headers.len() - 1] {
+            for header in &self.options.input_headers
+                [..self.options.input_headers.len() - 1]
+            {
                 output_vector.push("-include".to_string());
                 output_vector.push(header.clone());
             }
@@ -637,7 +638,7 @@ impl Builder {
     ///     .unwrap();
     /// ```
     pub fn header<T: Into<String>>(mut self, header: T) -> Builder {
-        self.input_headers.push(header.into());
+        self.options.input_headers.push(header.into());
         self
     }
 
@@ -1533,13 +1534,14 @@ impl Builder {
     /// Generate the Rust bindings using the options built up thus far.
     pub fn generate(mut self) -> Result<Bindings, BindgenError> {
         // Add any extra arguments from the environment to the clang command line.
-        self.options.clang_args.extend(get_extra_clang_args());
+        self.state.clang_args.extend(get_extra_clang_args());
 
         // 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.clang_args.extend(
-            self.options
+        self.state.input_header = self.options.input_headers.pop();
+        self.state.extra_input_headers =
+            std::mem::take(&mut self.options.input_headers);
+        self.state.clang_args.extend(
+            self.state
                 .extra_input_headers
                 .iter()
                 .flat_map(|header| ["-include".into(), header.to_string()]),
@@ -1575,10 +1577,10 @@ impl Builder {
         let mut wrapper_contents = String::new();
 
         // Whether we are working with C or C++ inputs.
-        let mut is_cpp = args_are_cpp(&self.options.clang_args);
+        let mut is_cpp = args_are_cpp(&self.state.clang_args);
 
         // For each input header, add `#include "$header"`.
-        for header in &self.input_headers {
+        for header in &self.options.input_headers {
             is_cpp |= file_is_cpp(header);
 
             wrapper_contents.push_str("#include \"");
@@ -1616,7 +1618,7 @@ impl Builder {
             .arg(&wrapper_path)
             .stdout(Stdio::piped());
 
-        for a in &self.options.clang_args {
+        for a in &self.state.clang_args {
             cmd.arg(a);
         }
 
@@ -1938,11 +1940,8 @@ struct BindgenOptions {
     /// The set of arguments to pass straight through to Clang.
     clang_args: Vec<String>,
 
-    /// The input header file.
-    input_header: Option<String>,
-
-    /// Any additional input header files.
-    extra_input_headers: Vec<String>,
+    /// The input header files.
+    input_headers: Vec<String>,
 
     /// Which kind of items should we generate? By default, we'll generate all
     /// of them.
@@ -2125,8 +2124,7 @@ impl Default for BindgenOptions {
             raw_lines: Default::default(),
             module_lines: Default::default(),
             clang_args: Default::default(),
-            input_header: Default::default(),
-            extra_input_headers: Default::default(),
+            input_headers: Default::default(),
             codegen_config: CodegenConfig::all(),
             conservative_inline_namespaces: Default::default(),
             generate_comments: true,
@@ -2251,6 +2249,15 @@ struct BindgenState {
     /// The set of types that we should not derive `PartialEq` for.
     no_partialeq_types: RegexSet,
 
+    /// The set of arguments to pass straight through to Clang.
+    clang_args: Vec<String>,
+
+    /// The input header file.
+    input_header: Option<String>,
+
+    /// Any additional input header files.
+    extra_input_headers: Vec<String>,
+
     /// The set of types that we should not derive `Copy` for.
     no_copy_types: RegexSet,
 
@@ -2281,6 +2288,8 @@ impl ::std::panic::UnwindSafe for BindgenState {}
 
 impl BindgenState {
     fn build(&mut self, options: &BindgenOptions) {
+        self.clang_args.extend_from_slice(&options.clang_args);
+
         let mut regex_sets = [
             (&mut self.allowlisted_vars, &options.allowlisted_vars),
             (&mut self.allowlisted_types, &options.allowlisted_types),
@@ -2448,7 +2457,7 @@ impl Bindings {
     /// Generate bindings for the given options.
     pub(crate) fn generate(
         mut state: BindgenState,
-        mut options: BindgenOptions,
+        options: BindgenOptions,
     ) -> Result<Self, BindgenError> {
         ensure_libclang_is_loaded();
 
@@ -2463,7 +2472,7 @@ impl Bindings {
         state.build(&options);
 
         let (effective_target, explicit_target) =
-            find_effective_target(&options.clang_args);
+            find_effective_target(&state.clang_args);
 
         let is_host_build =
             rust_to_clang_target(HOST_TARGET) == effective_target;
@@ -2474,12 +2483,15 @@ impl Bindings {
         // opening libclang.so, it has to be the same architecture and thus the
         // check is fine.
         if !explicit_target && !is_host_build {
-            options
+            state
                 .clang_args
                 .insert(0, format!("--target={}", effective_target));
         };
 
-        fn detect_include_paths(options: &mut BindgenOptions) {
+        fn detect_include_paths(
+            options: &BindgenOptions,
+            state: &mut BindgenState,
+        ) {
             if !options.detect_include_paths {
                 return;
             }
@@ -2488,7 +2500,7 @@ impl Bindings {
             // promote them to `-isystem`.
             let clang_args_for_clang_sys = {
                 let mut last_was_include_prefix = false;
-                options
+                state
                     .clang_args
                     .iter()
                     .filter(|arg| {
@@ -2534,8 +2546,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_header.as_deref().map_or(false, file_is_cpp);
+            let is_cpp = args_are_cpp(&state.clang_args) ||
+                state.input_header.as_deref().map_or(false, file_is_cpp);
 
             let search_paths = if is_cpp {
                 clang.cpp_search_paths
@@ -2546,14 +2558,14 @@ impl Bindings {
             if let Some(search_paths) = search_paths {
                 for path in search_paths.into_iter() {
                     if let Ok(path) = path.into_os_string().into_string() {
-                        options.clang_args.push("-isystem".to_owned());
-                        options.clang_args.push(path);
+                        state.clang_args.push("-isystem".to_owned());
+                        state.clang_args.push(path);
                     }
                 }
             }
         }
 
-        detect_include_paths(&mut options);
+        detect_include_paths(&options, &mut state);
 
         #[cfg(unix)]
         fn can_read(perms: &std::fs::Permissions) -> bool {
@@ -2566,7 +2578,7 @@ impl Bindings {
             true
         }
 
-        if let Some(h) = options.input_header.as_ref() {
+        if let Some(h) = state.input_header.as_ref() {
             let path = Path::new(h);
             if let Ok(md) = std::fs::metadata(path) {
                 if md.is_dir() {
@@ -2577,17 +2589,17 @@ impl Bindings {
                         path.into(),
                     ));
                 }
-                options.clang_args.push(h.clone())
+                state.clang_args.push(h.clone())
             } else {
                 return Err(BindgenError::NotExist(path.into()));
             }
         }
 
         for (idx, f) in state.input_unsaved_files.iter().enumerate() {
-            if idx != 0 || options.input_header.is_some() {
-                options.clang_args.push("-include".to_owned());
+            if idx != 0 || state.input_header.is_some() {
+                state.clang_args.push("-include".to_owned());
             }
-            options.clang_args.push(f.name.to_str().unwrap().to_owned())
+            state.clang_args.push(f.name.to_str().unwrap().to_owned())
         }
 
         debug!("Fixed-up options: {:?}", options);