Add lifetime to MatSize

Author: twistedfall

binding-generator/src/settings.rs

@@ -46,6 +46,7 @@ pub use argument_override::{
 	arg_override_factory, property_override_factory, return_override_factory, ArgOverride, PropertyOverride, ReturnOverride,
 	ARG_OVERRIDE_SELF,
 };
+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;
@@ -71,6 +72,7 @@ use crate::type_ref::TypeRef;
 
 mod argument_names;
 mod argument_override;
+mod class_tweaks;
 mod const_tweak;
 mod element_exclude_kind;
 mod element_export_tweak;
@@ -106,6 +108,7 @@ pub struct Settings {
 	pub generator_module_tweaks: ModuleTweak<'static>,
 	pub property_override: PropertyOverride,
 	pub property_tweaks: PropertyTweaks,
+	pub class_tweak: ClassTweaks,
 }
 
 impl Settings {
@@ -125,6 +128,7 @@ impl Settings {
 			generator_module_tweaks: ModuleTweak::empty(),
 			property_override: PropertyOverride::default(),
 			property_tweaks: PropertyTweaks::default(),
+			class_tweak: ClassTweaks::default(),
 		}
 	}
 
@@ -144,6 +148,7 @@ impl Settings {
 			generator_module_tweaks: generator_module_tweaks_factory(module),
 			property_override: property_override_factory(module),
 			property_tweaks: property_tweaks_factory(module),
+			class_tweak: class_tweaks_factory(module),
 		}
 	}
 

binding-generator/src/settings/class_tweaks.rs

@@ -0,0 +1,17 @@
+use std::collections::HashMap;
+
+use crate::writer::rust_native::type_ref::Lifetime;
+
+pub type ClassTweaks = HashMap<&'static str, ClassTweak>;
+
+#[derive(Clone, Copy, Debug)]
+pub enum ClassTweak {
+	Lifetime(Lifetime),
+}
+
+pub fn class_tweaks_factory(module: &str) -> ClassTweaks {
+	match module {
+		"core" => HashMap::from([("cv::MatSize", ClassTweak::Lifetime(Lifetime::Custom("mat")))]),
+		_ => HashMap::default(),
+	}
+}

binding-generator/src/type_ref/kind.rs

@@ -456,6 +456,28 @@ impl<'tu, 'ge> TypeRefKind<'tu, 'ge> {
 			kind => kind.extern_pass_kind().is_by_void_ptr() || kind.as_string(type_hint).is_some(),
 		}
 	}
+
+	/// True if it's possible to borrow from this type in Rust
+	///
+	/// Used mainly to decide whether the return type of function should have explicit or elided lifetime.
+	pub fn rust_can_borrow(&self, type_hint: &TypeRefTypeHint) -> bool {
+		match self {
+			TypeRefKind::Array(elem, _) => elem.kind().rust_can_borrow(type_hint),
+			TypeRefKind::StdVector(vec) => vec.element_type().kind().rust_can_borrow(type_hint),
+			TypeRefKind::StdTuple(tup) => tup.elements().iter().any(|e| e.kind().rust_can_borrow(type_hint)),
+			TypeRefKind::RValueReference(inner) => inner.kind().rust_can_borrow(type_hint),
+			TypeRefKind::SmartPtr(ptr) => ptr.pointee().kind().rust_can_borrow(type_hint),
+			TypeRefKind::Typedef(tdef) => tdef.underlying_type_ref().kind().rust_can_borrow(type_hint),
+			TypeRefKind::Pointer(_) if self.is_rust_by_ptr(type_hint) => false,
+			TypeRefKind::Pointer(_) | TypeRefKind::Reference(_) => true,
+			TypeRefKind::Primitive(_, _)
+			| TypeRefKind::Class(_)
+			| TypeRefKind::Enum(_)
+			| TypeRefKind::Function(_)
+			| TypeRefKind::Generic(_)
+			| TypeRefKind::Ignored => false,
+		}
+	}
 }
 
 #[derive(Clone, Copy, Debug)]

binding-generator/src/writer/rust_native/class.rs

@@ -5,7 +5,9 @@ use std::borrow::Cow;
 use super::element::{DefaultRustNativeElement, RustElement};
 use super::RustNativeGeneratedElement;
 use crate::class::ClassKind;
+use crate::settings::ClassTweak;
 use crate::type_ref::{Constness, CppNameStyle, FishStyle, NameStyle};
+use crate::writer::rust_native::type_ref::Lifetime;
 use crate::{Class, Element, Func, IteratorExt};
 
 impl RustElement for Class<'_, '_> {
@@ -77,6 +79,7 @@ impl RustNativeGeneratedElement for Class<'_, '_> {
 pub trait ClassExt {
 	fn rust_trait_name(&self, style: NameStyle, constness: Constness) -> Cow<str>;
 	fn rust_as_raw_name(&self, constness: Constness) -> String;
+	fn rust_lifetime(&self) -> Option<Lifetime>;
 }
 
 impl ClassExt for Class<'_, '_> {
@@ -99,6 +102,24 @@ impl ClassExt for Class<'_, '_> {
 			name = self.rust_name(NameStyle::Declaration)
 		)
 	}
+
+	/// Rust lifetime use by the objects of this class
+	fn rust_lifetime(&self) -> Option<Lifetime> {
+		match self {
+			Class::Clang { gen_env, .. } =>
+			{
+				#[allow(clippy::bind_instead_of_map)]
+				gen_env
+					.settings
+					.class_tweak
+					.get(self.cpp_name(CppNameStyle::Reference).as_ref())
+					.and_then(|tweak| match tweak {
+						ClassTweak::Lifetime(lt) => Some(*lt),
+					})
+			}
+			Class::Desc(_) => None,
+		}
+	}
 }
 
 pub fn rust_generate_debug_fields<'f>(field_const_methods: impl IntoIterator<Item = Func<'f, 'f>>) -> String {

binding-generator/src/writer/rust_native/class/gen.rs

@@ -61,7 +61,13 @@ pub fn gen_simple_class(c: &Class, opencv_version: &str) -> String {
 		("fields", &fields),
 		(
 			"impl",
-			&gen_impl(c, const_methods.iter().chain(mut_methods.iter()), &rust_local, opencv_version),
+			&gen_impl(
+				c,
+				const_methods.iter().chain(mut_methods.iter()),
+				&rust_local,
+				"",
+				opencv_version,
+			),
 		),
 		("impls", &impls),
 	]))
@@ -89,10 +95,22 @@ pub fn gen_boxed_class(c: &Class, opencv_version: &str) -> String {
 	const_methods.extend(more_const_methods);
 	mut_methods.extend(more_mut_methods);
 
+	let (rust_decl_lt, rust_decl_for_lt, rust_elided_lt, rust_phantom_ref) = if let Some(lt) = c.rust_lifetime() {
+		let lt = lt.to_explicit();
+		(
+			format!("<{lt}>"),
+			format!(": for <{lt}>"),
+			"<'_>".to_string(),
+			format!("_d: PhantomData<&{lt} mut ()>,"),
+		)
+	} else {
+		("".to_string(), "".to_string(), "".to_string(), "".to_string())
+	};
+
 	let type_ref = c.type_ref();
 	let bases = c.bases();
 
-	let traits = gen_traits(c, &type_ref, &bases, &const_methods, &mut_methods, opencv_version);
+	let traits = gen_traits(c, type_ref.clone(), &bases, &const_methods, &mut_methods, opencv_version);
 
 	let rust_local = c.rust_name(NameStyle::decl());
 
@@ -116,7 +134,7 @@ pub fn gen_boxed_class(c: &Class, opencv_version: &str) -> String {
 
 	let mut bases = String::with_capacity(all_bases.len() * (BASE_TPL_SRC.len() + 64));
 	all_bases.iter().chain(iter::once(c)).for_each(|base| {
-		let base_type_ref = base.type_ref();
+		let (base_type_ref_const, base_type_ref_mut) = make_const_mut(base.type_ref());
 		BASE_TPL.interpolate_into(
 			&mut bases,
 			&HashMap::from([
@@ -128,22 +146,12 @@ pub fn gen_boxed_class(c: &Class, opencv_version: &str) -> String {
 					"base_rust_full_const",
 					&base.rust_trait_name(NameStyle::ref_(), Constness::Const),
 				),
-				("rust_local", &type_ref.rust_name(NameStyle::decl())),
+				("rust_local", &rust_local),
+				("rust_elided_lt", &rust_elided_lt),
 				("rust_as_raw_const", &base.rust_as_raw_name(Constness::Const)),
 				("rust_as_raw_mut", &base.rust_as_raw_name(Constness::Mut)),
-				(
-					"base_rust_extern_const",
-					&base_type_ref
-						.clone()
-						.with_inherent_constness(Constness::Const)
-						.rust_extern(ExternDir::ToCpp),
-				),
-				(
-					"base_rust_extern_mut",
-					&base_type_ref
-						.with_inherent_constness(Constness::Mut)
-						.rust_extern(ExternDir::ToCpp),
-				),
+				("base_rust_extern_const", &base_type_ref_const.rust_extern(ExternDir::ToCpp)),
+				("base_rust_extern_mut", &base_type_ref_mut.rust_extern(ExternDir::ToCpp)),
 			]),
 		)
 	});
@@ -160,26 +168,22 @@ pub fn gen_boxed_class(c: &Class, opencv_version: &str) -> String {
 			kind.as_static_method().is_some() || kind.as_constructor().is_some()
 		});
 
+	let (type_ref_const, type_ref_mut) = make_const_mut(type_ref);
 	BOXED_TPL.interpolate(&HashMap::from([
 		("doc_comment", c.rendered_doc_comment("///", opencv_version).as_str()),
 		("debug", &c.get_debug()),
 		("rust_local", &rust_local),
+		("rust_decl_lt", &rust_decl_lt),
+		("rust_decl_for_lt", &rust_decl_for_lt),
+		("rust_elided_lt", &rust_elided_lt),
+		("rust_phantom_ref", &rust_phantom_ref),
 		("rust_full", &c.rust_name(NameStyle::ref_())),
-		(
-			"rust_extern_const",
-			&type_ref
-				.clone()
-				.with_inherent_constness(Constness::Const)
-				.rust_extern(ExternDir::ToCpp),
-		),
-		(
-			"rust_extern_mut",
-			&type_ref.with_inherent_constness(Constness::Mut).rust_extern(ExternDir::ToCpp),
-		),
+		("rust_extern_const", &type_ref_const.rust_extern(ExternDir::ToCpp)),
+		("rust_extern_mut", &type_ref_mut.rust_extern(ExternDir::ToCpp)),
 		("traits", &traits),
 		("extern_delete", &extern_delete),
 		("bases", &bases),
-		("impl", &gen_impl(c, methods, &rust_local, opencv_version)),
+		("impl", &gen_impl(c, methods, &rust_local, &rust_decl_lt, opencv_version)),
 		("impls", &impls),
 	]))
 }
@@ -293,7 +297,13 @@ fn all_methods_const_mut<'tu, 'ge>(c: &Class<'tu, 'ge>) -> (Vec<Func<'tu, 'ge>>,
 	(const_methods, mut_methods)
 }
 
-fn gen_impl<'f>(c: &Class, methods: impl Iterator<Item = &'f Func<'f, 'f>>, rust_local: &str, opencv_version: &str) -> String {
+fn gen_impl<'f>(
+	c: &Class,
+	methods: impl Iterator<Item = &'f Func<'f, 'f>>,
+	rust_local: &str,
+	rust_decl_lt: &str,
+	opencv_version: &str,
+) -> String {
 	static IMPL_TPL: Lazy<CompiledInterpolation> = Lazy::new(|| include_str!("../tpl/class/impl.tpl.rs").compile_interpolation());
 
 	let consts = c.consts().iter().map(|c| c.gen_rust(opencv_version)).join("");
@@ -307,6 +317,7 @@ fn gen_impl<'f>(c: &Class, methods: impl Iterator<Item = &'f Func<'f, 'f>>, rust
 	} else {
 		IMPL_TPL.interpolate(&HashMap::from([
 			("rust_local", rust_local),
+			("rust_decl_lt", rust_decl_lt),
 			("consts", &consts),
 			("inherent_methods", &inherent_methods),
 		]))
@@ -315,7 +326,7 @@ fn gen_impl<'f>(c: &Class, methods: impl Iterator<Item = &'f Func<'f, 'f>>, rust
 
 fn gen_traits(
 	c: &Class,
-	type_ref: &TypeRef,
+	type_ref: TypeRef,
 	bases: &[Class],
 	const_methods: &[Func],
 	mut_methods: &[Func],
@@ -358,6 +369,7 @@ fn gen_traits(
 		opencv_version,
 	);
 
+	let (type_ref_const, type_ref_mut) = make_const_mut(type_ref);
 	TRAIT_TPL.interpolate(&HashMap::from([
 		("debug", c.get_debug().as_str()),
 		("rust_trait_local_mut", &c.rust_trait_name(NameStyle::decl(), Constness::Mut)),
@@ -368,20 +380,8 @@ fn gen_traits(
 		("rust_as_raw_const", &c.rust_as_raw_name(Constness::Const)),
 		("rust_as_raw_mut", &c.rust_as_raw_name(Constness::Mut)),
 		("rust_name_ref", &c.rust_name(NameStyle::ref_())),
-		(
-			"rust_extern_const",
-			&type_ref
-				.clone()
-				.with_inherent_constness(Constness::Const)
-				.rust_extern(ExternDir::ToCpp),
-		),
-		(
-			"rust_extern_mut",
-			&type_ref
-				.clone()
-				.with_inherent_constness(Constness::Mut)
-				.rust_extern(ExternDir::ToCpp),
-		),
+		("rust_extern_const", &type_ref_const.rust_extern(ExternDir::ToCpp)),
+		("rust_extern_mut", &type_ref_mut.rust_extern(ExternDir::ToCpp)),
 		("trait_bases_const", &trait_bases_const),
 		("trait_bases_mut", &trait_bases_mut),
 		("trait_const_methods", &trait_const_methods),
@@ -486,6 +486,16 @@ impl Impls for String {
 	}
 }
 
+fn make_const_mut<'tu, 'ge>(type_ref: TypeRef<'tu, 'ge>) -> (TypeRef<'tu, 'ge>, TypeRef<'tu, 'ge>) {
+	if type_ref.inherent_constness().is_const() {
+		let type_ref_mut = type_ref.clone().with_inherent_constness(Constness::Mut);
+		(type_ref, type_ref_mut)
+	} else {
+		let type_ref_const = type_ref.clone().with_inherent_constness(Constness::Const);
+		(type_ref_const, type_ref)
+	}
+}
+
 mod method {
 	use crate::func::{FuncCppBody, FuncDesc, FuncKind, ReturnKind};
 	use crate::type_ref::TypeRef;

binding-generator/src/writer/rust_native/func.rs

@@ -18,6 +18,7 @@ use crate::func::{FuncCppBody, FuncKind, FuncRustBody, FuncRustExtern, InheritCo
 use crate::name_pool::NamePool;
 use crate::settings::ARG_OVERRIDE_SELF;
 use crate::type_ref::{Constness, CppNameStyle, ExternDir, FishStyle, NameStyle, StrEnc, StrType, TypeRef, TypeRefTypeHint};
+use crate::writer::rust_native::class::ClassExt;
 use crate::writer::rust_native::type_ref::render_lane::FunctionProps;
 use crate::{reserved_rename, CompiledInterpolation, Element, Func, IteratorExt, NameDebug, StrExt, StringExt};
 
@@ -232,6 +233,7 @@ impl RustNativeGeneratedElement for Func<'_, '_> {
 		let mut forward_args = Vec::with_capacity(args.len());
 		let mut post_success_call_args = Vec::with_capacity(args.len());
 		let boxed_ref_arg = return_type_ref.type_hint().as_boxed_as_ref();
+		let mut any_arg_can_borrow = false;
 		if let Some(cls) = as_instance_method {
 			let constness = self.constness();
 			let cls_type_ref = cls.type_ref().with_inherent_constness(constness);
@@ -242,6 +244,7 @@ impl RustNativeGeneratedElement for Func<'_, '_> {
 				.map_or(Lifetime::Elided, |(_, _, lt)| lt);
 			decl_args.push(render_lane.rust_self_func_decl(lt));
 			call_args.push(render_lane.rust_arg_func_call("self"));
+			any_arg_can_borrow |= !cls_type_ref.kind().is_copy(cls_type_ref.type_hint());
 		}
 		let mut callback_arg_name: Option<&str> = None;
 		let function_props = FunctionProps {
@@ -254,6 +257,7 @@ impl RustNativeGeneratedElement for Func<'_, '_> {
 			let arg_kind = arg_type_ref.kind();
 			let render_lane = arg_type_ref.render_lane();
 			let render_lane = render_lane.to_dyn();
+			any_arg_can_borrow |= arg_kind.rust_can_borrow(arg_type_hint);
 			if arg.is_user_data() {
 				pre_post_arg_handle(
 					format!(
@@ -322,8 +326,20 @@ impl RustNativeGeneratedElement for Func<'_, '_> {
 		};
 		let return_lifetime = match boxed_ref_arg {
 			Some((_, _, lifetime)) => lifetime,
-			None if matches!(kind.as_ref(), FuncKind::Function | FuncKind::StaticMethod(_)) => Lifetime::statik(),
-			None => Lifetime::Elided,
+			None => {
+				if matches!(kind.as_ref(), FuncKind::Function | FuncKind::StaticMethod(_)) {
+					Lifetime::statik()
+				} else if let Some(lt) = return_type_ref
+					.kind()
+					.as_class()
+					.and_then(|cls| cls.rust_lifetime())
+					.filter(|_| !any_arg_can_borrow)
+				{
+					lt
+				} else {
+					Lifetime::Elided
+				}
+			}
 		};
 		let mut return_type_func_decl = return_type_ref.rust_return(FishStyle::No, return_lifetime);
 		if !return_kind.is_infallible() {