Extend property renaming to property tweaks

Author: twistedfall

binding-generator/src/class.rs

@@ -14,6 +14,7 @@ use crate::element::ExcludeKind;
 use crate::entity::{ControlFlowExt, ToEntity};
 use crate::field::FieldDesc;
 use crate::func::{FuncCppBody, FuncDesc, FuncKind, ReturnKind};
+use crate::settings::PropertyReadWrite;
 use crate::type_ref::{Constness, CppNameStyle, StrEnc, StrType, TypeRef, TypeRefDesc, TypeRefTypeHint};
 use crate::writer::rust_native::element::RustElement;
 use crate::{
@@ -438,71 +439,80 @@ impl<'tu, 'ge> Class<'tu, 'ge> {
 					let return_kind = ReturnKind::infallible(fld_type_kind.return_as_naked(fld_type_ref.type_hint()));
 					let fld_const = fld.constness();
 					let passed_by_ref = fld_type_kind.can_return_as_direct_reference();
-					let rust_custom_leafname = gen_env.settings.property_rename.get(fld_refname.as_ref()).copied();
+					let prop_tweak = gen_env.settings.property_tweaks.get(fld_refname.as_ref());
+					let rust_custom_leafname = prop_tweak.and_then(|tweak| tweak.rename);
+					let read_write = prop_tweak
+						.and_then(|tweak| tweak.read_write)
+						.unwrap_or(PropertyReadWrite::ReadWrite);
 					let fld_declname = fld_refname.localname();
-					let (mut read_const_yield, mut read_mut_yield) = if fld_const.is_mut() && passed_by_ref {
-						let read_const_func = if constness_filter.map_or(true, |c| c.is_const()) {
-							Some(Func::new_desc(
-								FuncDesc::new(
-									FuncKind::FieldAccessor(self.clone(), fld.clone()),
-									Constness::Const,
-									return_kind,
-									fld_declname,
-									Rc::clone(&rust_module),
-									[],
-									fld_type_ref.as_ref().clone().with_inherent_constness(Constness::Const),
-								)
-								.def_loc(def_loc.clone())
-								.doc_comment(Rc::clone(&doc_comment))
-								.cpp_body(FuncCppBody::ManualCall("{{name}}".into()))
-								.maybe_rust_custom_leafname(rust_custom_leafname),
-							))
+					let (mut read_const_yield, mut read_mut_yield) = if read_write.is_read() {
+						if fld_const.is_mut() && passed_by_ref {
+							let read_const_func = if constness_filter.map_or(true, |c| c.is_const()) {
+								Some(Func::new_desc(
+									FuncDesc::new(
+										FuncKind::FieldAccessor(self.clone(), fld.clone()),
+										Constness::Const,
+										return_kind,
+										fld_declname,
+										Rc::clone(&rust_module),
+										[],
+										fld_type_ref.as_ref().clone().with_inherent_constness(Constness::Const),
+									)
+									.def_loc(def_loc.clone())
+									.doc_comment(Rc::clone(&doc_comment))
+									.cpp_body(FuncCppBody::ManualCall("{{name}}".into()))
+									.maybe_rust_custom_leafname(rust_custom_leafname),
+								))
+							} else {
+								None
+							};
+							let read_mut_func = if constness_filter.map_or(true, |c| c.is_mut()) {
+								Some(Func::new_desc(
+									FuncDesc::new(
+										FuncKind::FieldAccessor(self.clone(), fld.clone()),
+										Constness::Mut,
+										return_kind,
+										format!("{fld_declname}Mut"),
+										Rc::clone(&rust_module),
+										[],
+										fld_type_ref.as_ref().clone().with_inherent_constness(Constness::Mut),
+									)
+									.def_loc(def_loc.clone())
+									.doc_comment(Rc::clone(&doc_comment))
+									.cpp_body(FuncCppBody::ManualCall("{{name}}".into()))
+									.maybe_rust_custom_leafname(rust_custom_leafname.map(|name| format!("{name}_mut"))),
+								))
+							} else {
+								None
+							};
+							(read_const_func, read_mut_func)
 						} else {
-							None
-						};
-						let read_mut_func = if constness_filter.map_or(true, |c| c.is_mut()) {
-							Some(Func::new_desc(
-								FuncDesc::new(
-									FuncKind::FieldAccessor(self.clone(), fld.clone()),
-									Constness::Mut,
-									return_kind,
-									format!("{fld_declname}Mut"),
-									Rc::clone(&rust_module),
-									[],
-									fld_type_ref.as_ref().clone().with_inherent_constness(Constness::Mut),
-								)
-								.def_loc(def_loc.clone())
-								.doc_comment(Rc::clone(&doc_comment))
-								.cpp_body(FuncCppBody::ManualCall("{{name}}".into()))
-								.maybe_rust_custom_leafname(rust_custom_leafname.map(|name| format!("{name}_mut"))),
-							))
-						} else {
-							None
-						};
-						(read_const_func, read_mut_func)
+							let single_read_func = if constness_filter.map_or(true, |c| c == fld_const) {
+								Some(Func::new_desc(
+									FuncDesc::new(
+										FuncKind::FieldAccessor(self.clone(), fld.clone()),
+										fld_const,
+										return_kind,
+										fld_declname,
+										Rc::clone(&rust_module),
+										[],
+										fld_type_ref.as_ref().clone(),
+									)
+									.def_loc(def_loc.clone())
+									.doc_comment(Rc::clone(&doc_comment))
+									.cpp_body(FuncCppBody::ManualCall("{{name}}".into()))
+									.maybe_rust_custom_leafname(rust_custom_leafname),
+								))
+							} else {
+								None
+							};
+							(single_read_func, None)
+						}
 					} else {
-						let single_read_func = if constness_filter.map_or(true, |c| c == fld_const) {
-							Some(Func::new_desc(
-								FuncDesc::new(
-									FuncKind::FieldAccessor(self.clone(), fld.clone()),
-									fld_const,
-									return_kind,
-									fld_declname,
-									Rc::clone(&rust_module),
-									[],
-									fld_type_ref.as_ref().clone(),
-								)
-								.def_loc(def_loc.clone())
-								.doc_comment(Rc::clone(&doc_comment))
-								.cpp_body(FuncCppBody::ManualCall("{{name}}".into()))
-								.maybe_rust_custom_leafname(rust_custom_leafname),
-							))
-						} else {
-							None
-						};
-						(single_read_func, None)
+						(None, None)
 					};
-					let mut write_yield = if constness_filter.map_or(true, |c| c.is_mut())
+					let mut write_yield = if read_write.is_write()
+						&& constness_filter.map_or(true, |c| c.is_mut())
 						&& !fld_type_ref.constness().is_const()
 						&& !fld_type_kind.as_fixed_array().is_some()
 					{

binding-generator/src/settings.rs

@@ -62,7 +62,7 @@ pub use implemented::{
 	IMPLEMENTED_SYSTEM_CLASSES,
 };
 use once_cell::sync::Lazy;
-pub use property_rename::{property_rename_factory, PropertyRename};
+pub use property_tweaks::{property_tweaks_factory, PropertyReadWrite, PropertyTweak, PropertyTweaks};
 
 use crate::func::FuncMatcher;
 use crate::type_ref::TypeRef;
@@ -81,7 +81,7 @@ mod func_specialize;
 mod func_unsafe;
 mod generator_module_tweaks;
 mod implemented;
-mod property_rename;
+mod property_tweaks;
 
 pub type TypeRefFactory = fn() -> TypeRef<'static, 'static>;
 
@@ -96,9 +96,9 @@ pub struct Settings {
 	pub func_replace: FuncReplace,
 	pub func_specialize: FuncSpecialize,
 	pub func_unsafe: FuncUnsafe,
-	pub generator_module_tweaks: ModuleTweak,
+	pub generator_module_tweaks: ModuleTweak<'static>,
 	pub property_override: PropertyOverride,
-	pub property_rename: PropertyRename,
+	pub property_tweaks: PropertyTweaks,
 }
 
 impl Settings {
@@ -114,7 +114,7 @@ impl Settings {
 			func_unsafe: FuncUnsafe::empty(),
 			generator_module_tweaks: ModuleTweak::empty(),
 			property_override: PropertyOverride::default(),
-			property_rename: PropertyRename::default(),
+			property_tweaks: PropertyTweaks::default(),
 		}
 	}
 
@@ -130,7 +130,7 @@ impl Settings {
 			func_unsafe: func_unsafe_factory(module),
 			generator_module_tweaks: generator_module_tweaks_factory(module),
 			property_override: property_override_factory(module),
-			property_rename: property_rename_factory(module),
+			property_tweaks: property_tweaks_factory(module),
 		}
 	}
 }

binding-generator/src/settings/func_exclude.rs

@@ -10,13 +10,11 @@ pub static FUNC_EXCLUDE: Lazy<HashSet<&str>> = Lazy::new(|| {
 		"cv_Mat_Mat_const_MatR_const_RangeX",    // duplicate of cv_Mat_Mat_Mat_VectorOfRange, but with pointers
 		"cv_Mat_copySize_const_MatR",            // internal function
 		"cv_Mat_operator___const_const_RangeX",  // duplicate of cv_Mat_operator___const_const_vectorLRangeGR, but with pointers
-		"cv_Mat_propStep_const_MatStep",         // MatStep type prevents assignment
 		"cv_Mat_push_back__const_voidX",         // internal method
 		"cv_Mat_operatorST_const_MatR",          // unsafe with the safe version that moves
 		"cv_UMat_UMat_const_UMatR_const_RangeX", // duplicate of cv_UMat_UMat_UMat_VectorOfRange, but with pointers
 		"cv_UMat_copySize_const_UMatR",          // internal function
 		"cv_UMat_operator___const_const_RangeX", // duplicate of cv_UMat_operator___const_const_vectorLRangeGR, but with pointers
-		"cv_UMat_propStep_const_MatStep",        // MatStep type prevents assignment
 		"cv_RNG_MT19937_operator__",             // the same as calling to_u32() or next()
 		"cv_addImpl_int_const_charX",
 		"cv_calcCovarMatrix_const_MatX_int_MatR_MatR_int_int", // duplicate of cv_calcCovarMatrix_const__InputArrayR_const__OutputArrayR_const__InputOutputArrayR_int_int, but with pointers

binding-generator/src/settings/property_rename.rs

@@ -0,0 +1,76 @@
+use std::collections::HashMap;
+
+pub type PropertyTweaks = HashMap<&'static str, PropertyTweak<'static>>;
+
+#[derive(Debug)]
+pub struct PropertyTweak<'l> {
+	pub rename: Option<&'l str>,
+	pub read_write: Option<PropertyReadWrite>,
+}
+
+/// Rename property, format: (cpp_refname -> rust_custom_leafname)
+pub fn property_tweaks_factory(module: &str) -> PropertyTweaks {
+	match module {
+		"core" => HashMap::from([
+			(
+				"cv::Mat::size",
+				PropertyTweak {
+					rename: Some("mat_size"),
+					..PropertyTweak::none()
+				},
+			),
+			(
+				"cv::Mat::step",
+				PropertyTweak {
+					rename: Some("mat_step"),
+					read_write: Some(PropertyReadWrite::ReadOnly), // MatStep type prevents assignment
+				},
+			),
+			(
+				"cv::UMat::size",
+				PropertyTweak {
+					rename: Some("mat_size"),
+					..PropertyTweak::none()
+				},
+			),
+			(
+				"cv::UMat::step",
+				PropertyTweak {
+					rename: Some("mat_step"),
+					read_write: Some(PropertyReadWrite::ReadOnly), // MatStep type prevents assignment
+				},
+			),
+		]),
+		_ => HashMap::new(),
+	}
+}
+
+impl PropertyTweak<'_> {
+	pub fn none() -> PropertyTweak<'static> {
+		PropertyTweak {
+			rename: None,
+			read_write: None,
+		}
+	}
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum PropertyReadWrite {
+	ReadOnly,
+	ReadWrite,
+}
+
+impl PropertyReadWrite {
+	pub fn is_read(self) -> bool {
+		match self {
+			PropertyReadWrite::ReadOnly | PropertyReadWrite::ReadWrite => true,
+		}
+	}
+
+	pub fn is_write(self) -> bool {
+		match self {
+			PropertyReadWrite::ReadWrite => true,
+			PropertyReadWrite::ReadOnly => false,
+		}
+	}
+}