Merge generic enum tags

Author: Benjamin-Davies

src/bindgen/config.rs

@@ -598,6 +598,8 @@ pub struct EnumConfig {
     /// Whether to generate empty, private default-constructors for tagged
     /// enums.
     pub private_default_tagged_enum_constructor: bool,
+    /// Whether to only output a single tag enum for generic tagged enums.
+    pub merge_generic_tags: bool,
 }
 
 impl Default for EnumConfig {
@@ -618,6 +620,7 @@ impl Default for EnumConfig {
             derive_ostream: false,
             enum_class: true,
             private_default_tagged_enum_constructor: false,
+            merge_generic_tags: false,
         }
     }
 }

src/bindgen/ir/enumeration.rs

@@ -2,7 +2,9 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use std::cell::Cell;
 use std::io::Write;
+use std::rc::Rc;
 
 use syn::ext::IdentExt;
 
@@ -270,8 +272,13 @@ impl EnumVariant {
         mappings: &[(&Path, &GenericArgument)],
         config: &Config,
     ) -> Self {
+        let name = if config.enumeration.merge_generic_tags {
+            self.name.clone()
+        } else {
+            mangle::mangle_name(&self.name, generic_values, &config.export.mangle)
+        };
         Self::new(
-            mangle::mangle_name(&self.name, generic_values, &config.export.mangle),
+            name,
             self.discriminant.clone(),
             self.body.specialize(generic_values, mappings, config),
             self.cfg.clone(),
@@ -320,11 +327,15 @@ impl Source for EnumVariant {
 #[derive(Debug, Clone)]
 pub struct Enum {
     pub path: Path,
+    pub unmangled_path: Path,
     pub export_name: String,
+    pub unmangled_export_name: String,
     pub generic_params: GenericParams,
     pub repr: Repr,
     pub variants: Vec<EnumVariant>,
     pub tag: Option<String>,
+    /// Keep track of whether any instance of this enum has had its tag written.
+    pub tag_written: Rc<Cell<bool>>,
     pub cfg: Option<Cfg>,
     pub annotations: AnnotationSet,
     pub documentation: Documentation,
@@ -433,11 +444,13 @@ impl Enum {
         };
 
         Ok(Enum::new(
+            path.clone(),
             path,
             generic_params,
             repr,
             variants,
             tag,
+            Rc::new(Cell::new(false)),
             Cfg::append(mod_cfg, Cfg::load(&item.attrs)),
             annotations,
             Documentation::load(&item.attrs),
@@ -447,22 +460,28 @@ impl Enum {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         path: Path,
+        unmangled_path: Path,
         generic_params: GenericParams,
         repr: Repr,
         variants: Vec<EnumVariant>,
         tag: Option<String>,
+        tag_written: Rc<Cell<bool>>,
         cfg: Option<Cfg>,
         annotations: AnnotationSet,
         documentation: Documentation,
     ) -> Self {
         let export_name = path.name().to_owned();
+        let unmangled_export_name = unmangled_path.name().to_owned();
         Self {
             path,
+            unmangled_path,
             export_name,
+            unmangled_export_name,
             generic_params,
             repr,
             variants,
             tag,
+            tag_written,
             cfg,
             annotations,
             documentation,
@@ -518,10 +537,16 @@ impl Item for Enum {
 
     fn rename_for_config(&mut self, config: &Config) {
         config.export.rename(&mut self.export_name);
+        config.export.rename(&mut self.unmangled_export_name);
 
         if config.language != Language::Cxx && self.tag.is_some() {
             // it makes sense to always prefix Tag with type name in C
-            let new_tag = format!("{}_Tag", self.export_name);
+            let base_name = if config.enumeration.merge_generic_tags {
+                &self.unmangled_export_name
+            } else {
+                &self.export_name
+            };
+            let new_tag = format!("{}_Tag", base_name);
             if self.repr.style == ReprStyle::Rust {
                 for variant in &mut self.variants {
                     if let VariantBody::Body { ref mut body, .. } = variant.body {
@@ -560,11 +585,16 @@ impl Item for Enum {
             };
 
             for variant in &mut self.variants {
+                let export_name = if config.enumeration.merge_generic_tags {
+                    &self.unmangled_export_name
+                } else {
+                    &self.export_name
+                };
                 variant.export_name =
-                    format!("{}{}{}", self.export_name, separator, variant.export_name);
+                    format!("{}{}{}", export_name, separator, variant.export_name);
                 if let VariantBody::Body { ref mut body, .. } = variant.body {
                     body.export_name =
-                        format!("{}{}{}", self.export_name, separator, body.export_name());
+                        format!("{}{}{}", export_name, separator, body.export_name());
                 }
             }
         }
@@ -632,13 +662,15 @@ impl Item for Enum {
 
         let monomorph = Enum::new(
             mangled_path,
+            self.unmangled_path.clone(),
             GenericParams::default(),
             self.repr,
             self.variants
                 .iter()
                 .map(|v| v.specialize(generic_values, &mappings, library.get_config()))
                 .collect(),
             self.tag.clone(),
+            self.tag_written.clone(),
             self.cfg.clone(),
             self.annotations.clone(),
             self.documentation.clone(),
@@ -747,6 +779,12 @@ impl Enum {
         has_data: bool,
         tag_name: &str,
     ) {
+        // Only emit the tag enum once if merge_generic_tags is set.
+        if config.enumeration.merge_generic_tags && self.tag_written.get() {
+            return;
+        }
+        self.tag_written.set(true);
+
         // Open the tag enum.
         match config.language {
             Language::C => {

tests/expectations/merge_generic_tags.both.c

@@ -0,0 +1,31 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum COption_Tag {
+  Some,
+  None,
+} COption_Tag;
+
+typedef struct COption_u8 {
+  COption_Tag tag;
+  union {
+    struct {
+      uint8_t some;
+    };
+  };
+} COption_u8;
+
+
+
+typedef struct COption_u32 {
+  COption_Tag tag;
+  union {
+    struct {
+      uint32_t some;
+    };
+  };
+} COption_u32;
+
+void root(struct COption_u8 a, struct COption_u32 b);

tests/expectations/merge_generic_tags.both.compat.c

@@ -0,0 +1,39 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum COption_Tag {
+  Some,
+  None,
+} COption_Tag;
+
+typedef struct COption_u8 {
+  COption_Tag tag;
+  union {
+    struct {
+      uint8_t some;
+    };
+  };
+} COption_u8;
+
+
+
+typedef struct COption_u32 {
+  COption_Tag tag;
+  union {
+    struct {
+      uint32_t some;
+    };
+  };
+} COption_u32;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(struct COption_u8 a, struct COption_u32 b);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

tests/expectations/merge_generic_tags.c

@@ -0,0 +1,31 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum {
+  Some,
+  None,
+} COption_Tag;
+
+typedef struct {
+  COption_Tag tag;
+  union {
+    struct {
+      uint8_t some;
+    };
+  };
+} COption_u8;
+
+
+
+typedef struct {
+  COption_Tag tag;
+  union {
+    struct {
+      uint32_t some;
+    };
+  };
+} COption_u32;
+
+void root(COption_u8 a, COption_u32 b);

tests/expectations/merge_generic_tags.compat.c

@@ -0,0 +1,39 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef enum {
+  Some,
+  None,
+} COption_Tag;
+
+typedef struct {
+  COption_Tag tag;
+  union {
+    struct {
+      uint8_t some;
+    };
+  };
+} COption_u8;
+
+
+
+typedef struct {
+  COption_Tag tag;
+  union {
+    struct {
+      uint32_t some;
+    };
+  };
+} COption_u32;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void root(COption_u8 a, COption_u32 b);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus

tests/expectations/merge_generic_tags.cpp

@@ -0,0 +1,28 @@
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+template<typename T>
+struct COption {
+  enum class Tag {
+    Some,
+    None,
+  };
+
+  struct Some_Body {
+    T _0;
+  };
+
+  Tag tag;
+  union {
+    Some_Body some;
+  };
+};
+
+extern "C" {
+
+void root(COption<uint8_t> a, COption<uint32_t> b);
+
+} // extern "C"

tests/expectations/merge_generic_tags.pyx

@@ -0,0 +1,23 @@
+from libc.stdint cimport int8_t, int16_t, int32_t, int64_t, intptr_t
+from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t, uintptr_t
+cdef extern from *:
+  ctypedef bint bool
+  ctypedef struct va_list
+
+cdef extern from *:
+
+  ctypedef enum COption_Tag:
+    Some,
+    None,
+
+  ctypedef struct COption_u8:
+    COption_Tag tag;
+    uint8_t some;
+
+
+
+  ctypedef struct COption_u32:
+    COption_Tag tag;
+    uint32_t some;
+
+  void root(COption_u8 a, COption_u32 b);

tests/expectations/merge_generic_tags.tag.c

@@ -0,0 +1,31 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+enum COption_Tag {
+  Some,
+  None,
+};
+
+struct COption_u8 {
+  enum COption_Tag tag;
+  union {
+    struct {
+      uint8_t some;
+    };
+  };
+};
+
+
+
+struct COption_u32 {
+  enum COption_Tag tag;
+  union {
+    struct {
+      uint32_t some;
+    };
+  };
+};
+
+void root(struct COption_u8 a, struct COption_u32 b);