Merge branch 'jb/anonymous-enum-variant-rename' into jb/issue-1454-alt

Author: Jethro Beekman

src/ir/context.rs

@@ -2299,7 +2299,9 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                             let mut prefix_path =
                                 parent.path_for_allowlisting(self).clone();
                             enum_.variants().iter().any(|variant| {
-                                prefix_path.push(variant.name().into());
+                                prefix_path.push(
+                                    variant.name_for_allowlisting().into(),
+                                );
                                 let name = prefix_path[1..].join("::");
                                 prefix_path.pop().unwrap();
                                 self.options().allowlisted_vars.matches(&name)

src/ir/enum_ty.rs

@@ -118,7 +118,7 @@ impl Enum {
                             }
                         });
 
-                    let name = ctx
+                    let new_name = ctx
                         .parse_callbacks()
                         .and_then(|callbacks| {
                             callbacks.enum_variant_name(type_name, &name, val)
@@ -130,10 +130,11 @@ impl Enum {
                                 .last()
                                 .cloned()
                         })
-                        .unwrap_or(name);
+                        .unwrap_or_else(|| name.clone());
 
                     let comment = cursor.raw_comment();
                     variants.push(EnumVariant::new(
+                        new_name,
                         name,
                         comment,
                         val,
@@ -224,6 +225,9 @@ pub struct EnumVariant {
     /// The name of the variant.
     name: String,
 
+    /// The original name of the variant (without user mangling)
+    name_for_allowlisting: String,
+
     /// An optional doc comment.
     comment: Option<String>,
 
@@ -251,12 +255,14 @@ impl EnumVariant {
     /// Construct a new enumeration variant from the given parts.
     pub fn new(
         name: String,
+        name_for_allowlisting: String,
         comment: Option<String>,
         val: EnumVariantValue,
         custom_behavior: Option<EnumVariantCustomBehavior>,
     ) -> Self {
         EnumVariant {
             name,
+            name_for_allowlisting,
             comment,
             val,
             custom_behavior,
@@ -268,6 +274,11 @@ impl EnumVariant {
         &self.name
     }
 
+    /// Get this variant's name.
+    pub fn name_for_allowlisting(&self) -> &str {
+        &self.name_for_allowlisting
+    }
+
     /// Get this variant's value.
     pub fn val(&self) -> EnumVariantValue {
         self.val

tests/expectations/tests/parsecb-anonymous-enum-variant-rename.rs

@@ -0,0 +1,9 @@
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+pub const RENAMED_MyVal: ::std::os::raw::c_uint = 0;
+pub type _bindgen_ty_1 = ::std::os::raw::c_uint;

tests/headers/parsecb-anonymous-enum-variant-rename.h

@@ -0,0 +1,6 @@
+// bindgen-flags: --allowlist-var ^MyVal$
+// bindgen-parse-callbacks: enum-variant-rename
+
+enum {
+    MyVal = 0,
+};

tests/parse_callbacks/mod.rs

@@ -0,0 +1,22 @@
+use bindgen::callbacks::ParseCallbacks;
+
+#[derive(Debug)]
+struct EnumVariantRename;
+
+impl ParseCallbacks for EnumVariantRename {
+    fn enum_variant_name(
+        &self,
+        _enum_name: Option<&str>,
+        original_variant_name: &str,
+        _variant_value: bindgen::callbacks::EnumVariantValue,
+    ) -> Option<String> {
+        Some(format!("RENAMED_{}", original_variant_name))
+    }
+}
+
+pub fn lookup(cb: &str) -> Box<dyn ParseCallbacks> {
+    match cb {
+        "enum-variant-rename" => Box::new(EnumVariantRename),
+        _ => panic!("Couldn't find name ParseCallbacks: {}", cb),
+    }
+}

tests/tests.rs

@@ -17,6 +17,8 @@ use std::sync::Once;
 mod options;
 use crate::options::builder_from_flags;
 
+mod parse_callbacks;
+
 // Run `rustfmt` on the given source string and return a tuple of the formatted
 // bindings, and rustfmt's stderr.
 fn rustfmt(source: String) -> (String, String) {
@@ -115,7 +117,7 @@ The latest `rustfmt` is required to run the `bindgen` test suite. Install
 
 fn compare_generated_header(
     header: &PathBuf,
-    builder: Builder,
+    builder: BuilderState,
     check_roundtrip: bool,
 ) -> Result<(), Error> {
     let file_name = header.file_name().ok_or(Error::new(
@@ -190,13 +192,7 @@ fn compare_generated_header(
         ),
     };
 
-    let flags = if check_roundtrip {
-        let mut flags = builder.command_line_flags();
-        flags.insert(0, "bindgen".into());
-        flags
-    } else {
-        vec![]
-    };
+    let (builder, roundtrip_builder) = builder.into_builder(check_roundtrip)?;
 
     // We skip the generate() error here so we get a full diff below
     let (actual, rustfmt_stderr) = match builder.generate() {
@@ -262,8 +258,7 @@ fn compare_generated_header(
         return Err(Error::new(ErrorKind::Other, "Header and binding differ! Run with BINDGEN_OVERWRITE_EXPECTED=1 in the environment to automatically overwrite the expectation or with BINDGEN_TESTS_DIFFTOOL=meld to do this manually."));
     }
 
-    if check_roundtrip {
-        let roundtrip_builder = builder_from_flags(flags.into_iter())?.0;
+    if let Some(roundtrip_builder) = roundtrip_builder {
         if let Err(e) =
             compare_generated_header(&header, roundtrip_builder, false)
         {
@@ -281,7 +276,36 @@ fn builder() -> Builder {
     bindgen::builder().disable_header_comment()
 }
 
-fn create_bindgen_builder(header: &PathBuf) -> Result<Builder, Error> {
+struct BuilderState {
+    builder: Builder,
+    parse_callbacks: Vec<String>,
+}
+
+impl BuilderState {
+    fn into_builder(
+        self,
+        with_roundtrip_builder: bool,
+    ) -> Result<(Builder, Option<BuilderState>), Error> {
+        let roundtrip_builder = if with_roundtrip_builder {
+            let mut flags = self.builder.command_line_flags();
+            flags.insert(0, "bindgen".into());
+            let mut builder = builder_from_flags(flags.into_iter())?.0;
+            for parse_cb in &self.parse_callbacks {
+                builder =
+                    builder.parse_callbacks(parse_callbacks::lookup(parse_cb));
+            }
+            Some(BuilderState {
+                builder,
+                parse_callbacks: self.parse_callbacks,
+            })
+        } else {
+            None
+        };
+        Ok((self.builder, roundtrip_builder))
+    }
+}
+
+fn create_bindgen_builder(header: &PathBuf) -> Result<BuilderState, Error> {
     #[cfg(feature = "logging")]
     let _ = env_logger::try_init();
 
@@ -290,6 +314,7 @@ fn create_bindgen_builder(header: &PathBuf) -> Result<Builder, Error> {
 
     // Scoop up bindgen-flags from test header
     let mut flags = Vec::with_capacity(2);
+    let mut parse_callbacks = vec![];
 
     for line in reader.lines() {
         let line = line?;
@@ -311,6 +336,10 @@ fn create_bindgen_builder(header: &PathBuf) -> Result<Builder, Error> {
                 .map(ToString::to_string)
                 .chain(flags)
                 .collect();
+        } else if line.contains("bindgen-parse-callbacks: ") {
+            let parse_cb =
+                line.split("bindgen-parse-callbacks: ").last().unwrap();
+            parse_callbacks.push(parse_cb.to_owned());
         }
     }
 
@@ -353,7 +382,14 @@ fn create_bindgen_builder(header: &PathBuf) -> Result<Builder, Error> {
         .map(ToString::to_string)
         .chain(flags.into_iter());
 
-    builder_from_flags(args).map(|(builder, _, _)| builder)
+    let mut builder = builder_from_flags(args)?.0;
+    for parse_cb in &parse_callbacks {
+        builder = builder.parse_callbacks(parse_callbacks::lookup(parse_cb));
+    }
+    Ok(BuilderState {
+        builder,
+        parse_callbacks,
+    })
 }
 
 macro_rules! test_header {