Implement bitfield enums

Author: twistedfall

binding-generator/src/class.rs

@@ -159,14 +159,18 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 	}
 
 	/// Special case of an empty class with only an anonymous enum inside (e.g., DrawLinesMatchesFlags)
-	pub fn as_enum(&self) -> Option<Enum<'tu>> {
+	pub fn as_enum(&self) -> Option<Enum<'tu, 'ge>> {
 		match self {
-			&Self::Clang { entity, .. } => {
+			&Self::Clang { entity, gen_env, .. } => {
 				if !self.has_methods() && !self.has_fields() && !self.has_descendants() && !self.has_bases() {
 					let children = entity.get_children();
 					if let [single] = children.as_slice() {
 						if matches!(single.get_kind(), EntityKind::EnumDecl) {
-							Some(Enum::new_ext(*single, self.cpp_name(CppNameStyle::Declaration).as_ref()))
+							Some(Enum::new_ext(
+								*single,
+								self.cpp_name(CppNameStyle::Declaration).as_ref(),
+								gen_env,
+							))
 						} else {
 							None
 						}

binding-generator/src/enumeration.rs

@@ -8,25 +8,44 @@ use clang::{Entity, EntityKind, EntityVisitResult};
 use crate::debug::LocationName;
 use crate::element::ExcludeKind;
 use crate::type_ref::CppNameStyle;
-use crate::{Const, DefaultElement, Element, EntityElement, EntityExt, NameDebug, StrExt};
+use crate::{Const, DefaultElement, Element, EntityElement, EntityExt, GeneratorEnv, NameDebug, StrExt};
 
-#[derive(Clone, PartialEq)]
-pub struct Enum<'tu> {
+#[derive(Debug, Clone, Copy)]
+pub enum EnumBitfield {
+	NotBitfield,
+	BitfieldWithoutZero,
+	BitfieldWithZero,
+}
+
+impl EnumBitfield {
+	pub fn is_bitfield(self) -> bool {
+		match self {
+			Self::NotBitfield => false,
+			Self::BitfieldWithoutZero | Self::BitfieldWithZero => true,
+		}
+	}
+}
+
+#[derive(Clone)]
+pub struct Enum<'tu, 'ge> {
 	entity: Entity<'tu>,
+	gen_env: &'ge GeneratorEnv<'tu>,
 	custom_fullname: Option<Rc<str>>,
 }
 
-impl<'tu> Enum<'tu> {
-	pub fn new(entity: Entity<'tu>) -> Self {
+impl<'tu, 'ge> Enum<'tu, 'ge> {
+	pub fn new(entity: Entity<'tu>, gen_env: &'ge GeneratorEnv<'tu>) -> Self {
 		Self {
 			entity,
+			gen_env,
 			custom_fullname: None,
 		}
 	}
 
-	pub fn new_ext(entity: Entity<'tu>, custom_fullname: impl Into<Rc<str>>) -> Self {
+	pub fn new_ext(entity: Entity<'tu>, custom_fullname: impl Into<Rc<str>>, gen_env: &'ge GeneratorEnv<'tu>) -> Self {
 		Self {
 			entity,
+			gen_env,
 			custom_fullname: Some(custom_fullname.into()),
 		}
 	}
@@ -58,15 +77,69 @@ impl<'tu> Enum<'tu> {
 		});
 		out
 	}
+
+	/// True if this enum is bitfield, e.g. intended to be used as a combination of flags.
+	pub fn bitfield(&self) -> EnumBitfield {
+		let name = self.cpp_name(CppNameStyle::Reference);
+		if name.ends_with("Flags") || name.ends_with("FLAGS") || name.ends_with("Settings") {
+			self
+				.gen_env
+				.settings
+				.enum_bitfield_override
+				.get(name.as_ref())
+				.copied()
+				.unwrap_or_else(|| {
+					let mut has_zero = false;
+					let mut var_count = 0;
+					let not_bitfield = self.as_typedefed().unwrap_or(self.entity).visit_children(|const_decl, _| {
+						if const_decl.get_kind() != EntityKind::EnumConstantDecl {
+							return EntityVisitResult::Continue;
+						}
+						if let Some(val) = const_decl
+							.get_enum_constant_value()
+							.and_then(|(val, _)| u64::try_from(val).ok())
+						{
+							var_count += 1;
+							if val == 0 {
+								has_zero = true;
+								EntityVisitResult::Continue
+							} else if val.is_power_of_two() {
+								EntityVisitResult::Continue
+							} else {
+								EntityVisitResult::Break
+							}
+						} else {
+							EntityVisitResult::Break
+						}
+					});
+					if not_bitfield {
+						EnumBitfield::NotBitfield
+					} else if has_zero {
+						if var_count <= 2 {
+							// enum with 0 and one/no other option is self-exclusive, no point in bitfield machinery
+							EnumBitfield::NotBitfield
+						} else {
+							EnumBitfield::BitfieldWithZero
+						}
+					} else if var_count <= 1 {
+						EnumBitfield::NotBitfield
+					} else {
+						EnumBitfield::BitfieldWithoutZero
+					}
+				})
+		} else {
+			EnumBitfield::NotBitfield
+		}
+	}
 }
 
-impl<'tu> EntityElement<'tu> for Enum<'tu> {
+impl<'tu> EntityElement<'tu> for Enum<'tu, '_> {
 	fn entity(&self) -> Entity<'tu> {
 		self.entity
 	}
 }
 
-impl Element for Enum<'_> {
+impl Element for Enum<'_, '_> {
 	fn exclude_kind(&self) -> ExcludeKind {
 		DefaultElement::exclude_kind(self).with_is_excluded(|| self.as_typedefed().is_some())
 	}
@@ -100,13 +173,19 @@ impl Element for Enum<'_> {
 	}
 }
 
-impl<'me> NameDebug<'me> for &'me Enum<'_> {
+impl PartialEq for Enum<'_, '_> {
+	fn eq(&self, other: &Self) -> bool {
+		self.entity == other.entity && self.custom_fullname == other.custom_fullname
+	}
+}
+
+impl<'me> NameDebug<'me> for &'me Enum<'_, '_> {
 	fn file_line_name(self) -> LocationName<'me> {
 		self.entity.file_line_name()
 	}
 }
 
-impl fmt::Debug for Enum<'_> {
+impl fmt::Debug for Enum<'_, '_> {
 	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 		let mut debug_struct = f.debug_struct("Enum");
 		self

binding-generator/src/generator.rs

@@ -56,7 +56,7 @@ pub trait GeneratorVisitor<'tu>: Sized {
 	fn visit_const(&mut self, cnst: Const<'tu>) {}
 
 	/// Top-level enum
-	fn visit_enum(&mut self, enm: Enum<'tu>) {}
+	fn visit_enum(&mut self, enm: Enum<'tu, '_>) {}
 
 	/// Top-level function
 	fn visit_func(&mut self, func: Func<'tu, '_>) {}
@@ -142,7 +142,7 @@ impl<'tu, V: GeneratorVisitor<'tu>> EntityWalkerVisitor<'tu> for OpenCvWalker<'t
 			| EntityKind::ClassTemplate
 			| EntityKind::ClassTemplatePartialSpecialization
 			| EntityKind::StructDecl => Self::process_class(&mut self.visitor, &mut self.gen_env, entity),
-			EntityKind::EnumDecl => Self::process_enum(&mut self.visitor, entity),
+			EntityKind::EnumDecl => Self::process_enum(&mut self.visitor, &self.gen_env, entity),
 			EntityKind::FunctionDecl => Self::process_func(&mut self.visitor, &mut self.func_names, &self.gen_env, entity),
 			EntityKind::TypedefDecl | EntityKind::TypeAliasDecl => Self::process_typedef(&mut self.visitor, &self.gen_env, entity),
 			EntityKind::VarDecl => {
@@ -237,7 +237,7 @@ impl<'tu, 'r, V: GeneratorVisitor<'tu>> OpenCvWalker<'tu, 'r, V> {
 					visitor.visit_generated_type(dep);
 				});
 				let _ = class_decl.walk_enums_while(|enm| {
-					Self::process_enum(visitor, enm);
+					Self::process_enum(visitor, gen_env, enm);
 					ControlFlow::Continue(())
 				});
 				let _ = class_decl.walk_classes_while(|sub_cls| {
@@ -265,8 +265,8 @@ impl<'tu, 'r, V: GeneratorVisitor<'tu>> OpenCvWalker<'tu, 'r, V> {
 		}
 	}
 
-	fn process_enum(visitor: &mut V, enum_decl: Entity<'tu>) {
-		let enm = Enum::new(enum_decl);
+	fn process_enum(visitor: &mut V, gen_env: &GeneratorEnv<'tu>, enum_decl: Entity<'tu>) {
+		let enm = Enum::new(enum_decl, gen_env);
 		if enm.exclude_kind().is_included() {
 			for cnst in enm.consts() {
 				if cnst.exclude_kind().is_included() {

binding-generator/src/settings.rs

@@ -51,6 +51,7 @@ pub use class_tweaks::{class_tweaks_factory, ClassTweak, ClassTweaks};
 pub use const_tweak::CONST_TYPE_OVERRIDE;
 pub use element_exclude_kind::ELEMENT_EXCLUDE_KIND;
 pub use element_export_tweak::ELEMENT_EXPORT_TWEAK;
+pub use enum_bitfield_override::{enum_bitfield_override_factory, EnumBitfieldOverride};
 pub use force_infallible::{force_infallible_factory, ForceInfallible};
 pub use func_cfg_attr::{func_cfg_attr_factory, FuncCfgAttr, CFG_ATTR_NOT_ON_WINDOWS, CFG_ATTR_ONLY_OPENCV_5};
 pub use func_companion_tweak::{func_companion_tweak_factory, CompanionTweak, FuncCompanionTweak};
@@ -77,6 +78,7 @@ mod class_tweaks;
 mod const_tweak;
 mod element_exclude_kind;
 mod element_export_tweak;
+mod enum_bitfield_override;
 mod force_infallible;
 mod func_cfg_attr;
 mod func_companion_tweak;
@@ -97,6 +99,7 @@ pub type TypeRefFactory = fn() -> TypeRef<'static, 'static>;
 pub struct Settings {
 	pub arg_override: ArgOverride,
 	pub return_override: ReturnOverride,
+	pub enum_bitfield_override: EnumBitfieldOverride,
 	pub force_infallible: ForceInfallible,
 	pub func_cfg_attr: FuncCfgAttr,
 	pub func_companion_tweak: FuncCompanionTweak,
@@ -117,6 +120,7 @@ impl Settings {
 		Self {
 			arg_override: ArgOverride::empty(),
 			return_override: ReturnOverride::empty(),
+			enum_bitfield_override: EnumBitfieldOverride::default(),
 			force_infallible: ForceInfallible::empty(),
 			func_cfg_attr: FuncCfgAttr::empty(),
 			func_companion_tweak: FuncCompanionTweak::empty(),
@@ -137,6 +141,7 @@ impl Settings {
 		Self {
 			arg_override: arg_override_factory(module),
 			return_override: return_override_factory(module),
+			enum_bitfield_override: enum_bitfield_override_factory(module),
 			force_infallible: force_infallible_factory(module),
 			func_cfg_attr: func_cfg_attr_factory(module),
 			func_companion_tweak: func_companion_tweak_factory(module),

binding-generator/src/settings/enum_bitfield_override.rs

@@ -0,0 +1,17 @@
+use std::collections::HashMap;
+
+use EnumBitfield::NotBitfield;
+
+use crate::enumeration::EnumBitfield;
+use crate::SupportedModule;
+
+pub type EnumBitfieldOverride = HashMap<&'static str, EnumBitfield>;
+
+/// cpp_name(Reference)
+pub fn enum_bitfield_override_factory(module: SupportedModule) -> EnumBitfieldOverride {
+	match module {
+		SupportedModule::Core => HashMap::from([("cv::RotateFlags", NotBitfield)]),
+		SupportedModule::ImgCodecs => HashMap::from([("cv::ImwriteEXRTypeFlags", NotBitfield)]),
+		_ => HashMap::new(),
+	}
+}

binding-generator/src/type_ref/desc.rs

@@ -511,7 +511,10 @@ impl<'tu> ClangTypeExt<'tu> for Type<'tu> {
 					}
 				}
 
-				TypeKind::Enum => TypeRefKind::Enum(Enum::new(self.get_declaration().expect("Can't get enum declaration"))),
+				TypeKind::Enum => TypeRefKind::Enum(Enum::new(
+					self.get_declaration().expect("Can't get enum declaration"),
+					gen_env,
+				)),
 
 				TypeKind::FunctionPrototype => {
 					if let Some(parent) = parent_entity {

binding-generator/src/type_ref/kind.rs

@@ -23,7 +23,7 @@ pub enum TypeRefKind<'tu, 'ge> {
 	RValueReference(TypeRef<'tu, 'ge>),
 	SmartPtr(SmartPtr<'tu, 'ge>),
 	Class(Class<'tu, 'ge>),
-	Enum(Enum<'tu>),
+	Enum(Enum<'tu, 'ge>),
 	Function(Function<'tu, 'ge>),
 	Typedef(Typedef<'tu, 'ge>),
 	Generic(String),
@@ -161,7 +161,7 @@ impl<'tu, 'ge> TypeRefKind<'tu, 'ge> {
 		}
 	}
 
-	pub fn as_enum(&self) -> Option<&Enum<'tu>> {
+	pub fn as_enum(&self) -> Option<&Enum<'tu, 'ge>> {
 		if let TypeRefKind::Enum(out) = self {
 			Some(out)
 		} else {

binding-generator/src/typedef.rs

@@ -48,7 +48,7 @@ impl<'tu, 'ge> Typedef<'tu, 'ge> {
 						out = NewTypedefResult::Class(Class::new_ext(child, entity.cpp_name(CppNameStyle::Reference), gen_env));
 					}
 					EntityKind::EnumDecl => {
-						out = NewTypedefResult::Enum(Enum::new_ext(child, entity.cpp_name(CppNameStyle::Reference)));
+						out = NewTypedefResult::Enum(Enum::new_ext(child, entity.cpp_name(CppNameStyle::Reference), gen_env));
 					}
 					_ => {}
 				}
@@ -144,7 +144,7 @@ impl Element for Typedef<'_, '_> {
 pub enum NewTypedefResult<'tu, 'ge> {
 	Typedef(Typedef<'tu, 'ge>),
 	Class(Class<'tu, 'ge>),
-	Enum(Enum<'tu>),
+	Enum(Enum<'tu, 'ge>),
 }
 
 impl NewTypedefResult<'_, '_> {