rename non-extern to static

bindgen-cli/options.rs

@@ -355,15 +355,15 @@ struct BindgenCommand {
     with_derive_custom_union: Vec<String>,
     /// Generate wrappers for `static` and `static inline` functions.
     #[arg(long, requires = "experimental")]
-    wrap_non_extern_fns: bool,
+    wrap_static_fns: bool,
     /// Sets the path for the source file that must be created due to the presence of `static` and
     /// `static inline` functions.
     #[arg(long, requires = "experimental", value_name = "PATH")]
-    wrap_non_extern_fns_path: Option<PathBuf>,
+    wrap_static_fns_path: Option<PathBuf>,
     /// Sets the suffix added to the extern wrapper functions generated for `static` and `static
     /// inline` functions.
     #[arg(long, requires = "experimental", value_name = "SUFFIX")]
-    wrap_non_extern_fns_suffix: Option<String>,
+    wrap_static_fns_suffix: Option<String>,
     /// Enables experimental features.
     #[arg(long)]
     experimental: bool,
@@ -487,9 +487,9 @@ where
         with_derive_custom_struct,
         with_derive_custom_enum,
         with_derive_custom_union,
-        wrap_non_extern_fns,
-        wrap_non_extern_fns_path,
-        wrap_non_extern_fns_suffix,
+        wrap_static_fns,
+        wrap_static_fns_path,
+        wrap_static_fns_suffix,
         experimental: _,
         version,
         clang_args,
@@ -996,16 +996,16 @@ where
         }
     }
 
-    if wrap_non_extern_fns {
-        builder = builder.wrap_non_extern_fns(true);
+    if wrap_static_fns {
+        builder = builder.wrap_static_fns(true);
     }
 
-    if let Some(path) = wrap_non_extern_fns_path {
-        builder = builder.wrap_non_extern_fns_path(path);
+    if let Some(path) = wrap_static_fns_path {
+        builder = builder.wrap_static_fns_path(path);
     }
 
-    if let Some(suffix) = wrap_non_extern_fns_suffix {
-        builder = builder.wrap_non_extern_fns_suffix(suffix);
+    if let Some(suffix) = wrap_static_fns_suffix {
+        builder = builder.wrap_static_fns_suffix(suffix);
     }
 
     Ok((builder, output, verbose))

bindgen-integration/build.rs

@@ -214,7 +214,7 @@ fn setup_extern_test() {
     let input_header_dir = PathBuf::from("../bindgen-tests/tests/headers/")
         .canonicalize()
         .expect("Cannot canonicalize libdir path");
-    let input_header_file_path = input_header_dir.join("wrap-non-extern-fns.h");
+    let input_header_file_path = input_header_dir.join("wrap-static-fns.h");
     let input_header_file_path_str = input_header_file_path
         .to_str()
         .expect("Path could not be converted to a str");
@@ -223,8 +223,8 @@ fn setup_extern_test() {
     let bindings = Builder::default()
         .header(input_header_file_path_str)
         .parse_callbacks(Box::new(CargoCallbacks))
-        .wrap_non_extern_fns(true)
-        .non_extern_fns_directory(out_path.display().to_string())
+        .wrap_static_fns(true)
+        .static_fns_directory(out_path.display().to_string())
         .generate()
         .expect("Unable to generate bindings");
 

bindgen-tests/tests/expectations/tests/generated/README.md

@@ -1,4 +1,4 @@
 # Generated C, C++, Header files
 
 This directory contains files for features where extra files are generated
-as a part of the feature. For example, `--wrap-non-extern-fns`.
+as a part of the feature. For example, `--wrap-static-fns`.

bindgen-tests/tests/headers/wrap-non-extern-fns.h → bindgen-tests/tests/headers/wrap-static-fns.h

@@ -1,4 +1,4 @@
-// bindgen-flags: --experimental --wrap-non-extern-fns
+// bindgen-flags: --experimental --wrap-static-fns
 
 static inline int foo() {
     return 11;

bindgen-tests/tests/tests.rs

@@ -728,9 +728,9 @@ fn test_extern_generated_headers() {
     println!("Out path is ::: {}", generated_path.display());
 
     let _bindings = Builder::default()
-        .header("tests/headers/wrap-non-extern-fns.h")
-        .wrap_non_extern_fns(true)
-        .wrap_non_extern_fns_path(generated_path.display().to_string())
+        .header("tests/headers/wrap-static-fns.h")
+        .wrap_static_fns(true)
+        .wrap_static_fns_path(generated_path.display().to_string())
         .generate()
         .expect("Failed to generate bindings");
 

bindgen/codegen/mod.rs

@@ -4008,7 +4008,7 @@ impl CodeGenerator for Function {
         let is_internal = matches!(self.linkage(), Linkage::Internal);
 
         if is_internal {
-            if ctx.options().wrap_non_extern_fns {
+            if ctx.options().wrap_static_fns {
                 match CItem::from_function(self, ctx) {
                     Ok(c_item) => result.c_items.push(c_item),
                     Err(err) => warn!("Serialization failed: {:?}", err),
@@ -4148,12 +4148,8 @@ impl CodeGenerator for Function {
                 quote! { #[link(wasm_import_module = #name)] }
             });
 
-        if is_internal &&
-            ctx.options().wrap_non_extern_fns &&
-            !has_link_name_attr
-        {
-            let name =
-                canonical_name.clone() + ctx.wrap_non_extern_fns_suffix();
+        if is_internal && ctx.options().wrap_static_fns && !has_link_name_attr {
+            let name = canonical_name.clone() + ctx.wrap_static_fns_suffix();
 
             attributes.push(attributes::link_name(&name));
         }
@@ -4544,7 +4540,7 @@ pub mod utils {
     ) -> Result<(), std::io::Error> {
         let path = context
             .options()
-            .wrap_non_extern_fns_path
+            .wrap_static_fns_path
             .as_ref()
             .map(|path| PathBuf::from(path))
             .unwrap_or_else(|| {

bindgen/codegen/serialize.rs

@@ -73,7 +73,7 @@ impl CItem {
             " {}{}(",
             name,
             ctx.options()
-                .wrap_non_extern_fns_suffix
+                .wrap_static_fns_suffix
                 .as_deref()
                 .unwrap_or(DEFAULT_NON_EXTERN_FNS_SUFFIX)
         )?;

bindgen/ir/context.rs

@@ -2793,9 +2793,9 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         }
     }
 
-    pub(crate) fn wrap_non_extern_fns_suffix(&self) -> &str {
+    pub(crate) fn wrap_static_fns_suffix(&self) -> &str {
         self.options()
-            .wrap_non_extern_fns_suffix
+            .wrap_static_fns_suffix
             .as_deref()
             .unwrap_or(crate::DEFAULT_NON_EXTERN_FNS_SUFFIX)
     }

bindgen/ir/function.rs

@@ -94,9 +94,6 @@ pub struct Function {
 
     /// The linkage of the function.
     linkage: Linkage,
-
-    /// Is this function inlined?.
-    is_inlined_function: bool,
 }
 
 impl Function {
@@ -108,7 +105,6 @@ impl Function {
         comment: Option<String>,
         kind: FunctionKind,
         linkage: Linkage,
-        is_inlined_function: bool,
     ) -> Self {
         Function {
             name,
@@ -117,7 +113,6 @@ impl Function {
             comment,
             kind,
             linkage,
-            is_inlined_function,
         }
     }
 
@@ -150,11 +145,6 @@ impl Function {
     pub fn linkage(&self) -> Linkage {
         self.linkage
     }
-
-    /// Is this function inlined?
-    pub fn is_inlined_function(&self) -> bool {
-        self.is_inlined_function
-    }
 }
 
 impl DotAttributes for Function {
@@ -696,7 +686,7 @@ impl ClangSubItemParser for Function {
                 .map_or(false, |x| x.is_inlined_function())
         {
             if !context.options().generate_inline_functions &&
-                !context.options().wrap_non_extern_fns
+                !context.options().wrap_static_fns
             {
                 return Err(ParseError::Continue);
             }
@@ -705,7 +695,8 @@ impl ClangSubItemParser for Function {
                 return Err(ParseError::Continue);
             }
 
-            if context.options().wrap_non_extern_fns &&
+            // We cannot handle `inline` functions that are not `static`.
+            if context.options().wrap_static_fns &&
                 cursor.is_inlined_function() &&
                 matches!(linkage, Linkage::External)
             {
@@ -752,7 +743,6 @@ impl ClangSubItemParser for Function {
             comment,
             kind,
             linkage,
-            cursor.is_inlined_function(),
         );
 
         Ok(ParseResult::New(function, Some(cursor)))

bindgen/lib.rs

@@ -658,17 +658,17 @@ impl Builder {
         for callbacks in &self.options.parse_callbacks {
             output_vector.extend(callbacks.cli_args());
         }
-        if self.options.wrap_non_extern_fns {
-            output_vector.push("--wrap-non-extern-fns".into())
+        if self.options.wrap_static_fns {
+            output_vector.push("--wrap-static-fns".into())
         }
 
-        if let Some(ref path) = self.options.wrap_non_extern_fns_path {
-            output_vector.push("--wrap-non-extern-fns-path".into());
+        if let Some(ref path) = self.options.wrap_static_fns_path {
+            output_vector.push("--wrap-static-fns-path".into());
             output_vector.push(path.display().to_string());
         }
 
-        if let Some(ref suffix) = self.options.wrap_non_extern_fns_suffix {
-            output_vector.push("--wrap-non-extern-fns-suffix".into());
+        if let Some(ref suffix) = self.options.wrap_static_fns_suffix {
+            output_vector.push("--wrap-static-fns-suffix".into());
             output_vector.push(suffix.clone());
         }
 
@@ -1810,30 +1810,26 @@ impl Builder {
     #[cfg(feature = "experimental")]
     /// Whether to generate extern wrappers for `static` and `static inline` functions. Defaults to
     /// false.
-    pub fn wrap_non_extern_fns(mut self, doit: bool) -> Self {
-        self.options.wrap_non_extern_fns = doit;
+    pub fn wrap_static_fns(mut self, doit: bool) -> Self {
+        self.options.wrap_static_fns = doit;
         self
     }
 
     #[cfg(feature = "experimental")]
     /// Set the path for the source code file that would be created if any wrapper functions must
-    /// be generated due to the presence of non-extern functions.
+    /// be generated due to the presence of static functions.
     ///
     /// Bindgen will automatically add the right extension to the header and source code files.
-    pub fn wrap_non_extern_fns_path<T: AsRef<Path>>(mut self, path: T) -> Self {
-        self.options.wrap_non_extern_fns_path = Some(path.as_ref().to_owned());
+    pub fn wrap_static_fns_path<T: AsRef<Path>>(mut self, path: T) -> Self {
+        self.options.wrap_static_fns_path = Some(path.as_ref().to_owned());
         self
     }
 
     #[cfg(feature = "experimental")]
     /// Set the suffix added to the extern wrapper functions generated for `static` and `static
     /// inline` functions.
-    pub fn wrap_non_extern_fns_suffix<T: AsRef<str>>(
-        mut self,
-        suffix: T,
-    ) -> Self {
-        self.options.wrap_non_extern_fns_suffix =
-            Some(suffix.as_ref().to_owned());
+    pub fn wrap_static_fns_suffix<T: AsRef<str>>(mut self, suffix: T) -> Self {
+        self.options.wrap_static_fns_suffix = Some(suffix.as_ref().to_owned());
         self
     }
 }
@@ -2177,11 +2173,11 @@ struct BindgenOptions {
     /// Whether to wrap unsafe operations in unsafe blocks or not.
     wrap_unsafe_ops: bool,
 
-    wrap_non_extern_fns: bool,
+    wrap_static_fns: bool,
 
-    wrap_non_extern_fns_suffix: Option<String>,
+    wrap_static_fns_suffix: Option<String>,
 
-    wrap_non_extern_fns_path: Option<PathBuf>,
+    wrap_static_fns_path: Option<PathBuf>,
 }
 
 impl BindgenOptions {
@@ -2374,9 +2370,9 @@ impl Default for BindgenOptions {
             merge_extern_blocks,
             abi_overrides,
             wrap_unsafe_ops,
-            wrap_non_extern_fns,
-            wrap_non_extern_fns_suffix,
-            wrap_non_extern_fns_path,
+            wrap_static_fns,
+            wrap_static_fns_suffix,
+            wrap_static_fns_path,
         }
     }
 }