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_tweak::{ClassTweak, CLASS_TWEAK};
 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_tweak;
 mod const_tweak;
 mod element_exclude_kind;
 mod element_export_tweak;

binding-generator/src/settings/class_tweak.rs

@@ -0,0 +1,13 @@
+use std::collections::HashMap;
+
+use once_cell::sync::Lazy;
+
+use crate::writer::rust_native::type_ref::Lifetime;
+
+#[derive(Clone, Copy)]
+pub enum ClassTweak {
+	Lifetime(Lifetime),
+}
+
+pub static CLASS_TWEAK: Lazy<HashMap<&str, ClassTweak>> =
+	Lazy::new(|| HashMap::from([("cv::MatSize", ClassTweak::Lifetime(Lifetime::Custom("mat")))]));

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,8 +5,10 @@ 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::{Class, Element, Func, IteratorExt};
+use crate::writer::rust_native::type_ref::Lifetime;
+use crate::{settings, Class, Element, Func, IteratorExt};
 
 impl RustElement for Class<'_, '_> {
 	fn rust_module(&self) -> Cow<str> {
@@ -77,6 +79,8 @@ 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>;
+	fn rust_lifetime_count(&self) -> usize;
 }
 
 impl ClassExt for Class<'_, '_> {
@@ -99,6 +103,19 @@ impl ClassExt for Class<'_, '_> {
 			name = self.rust_name(NameStyle::Declaration)
 		)
 	}
+
+	fn rust_lifetime(&self) -> Option<Lifetime> {
+		#[allow(clippy::bind_instead_of_map)]
+		settings::CLASS_TWEAK
+			.get(self.cpp_name(CppNameStyle::Reference).as_ref())
+			.and_then(|tweak| match tweak {
+				ClassTweak::Lifetime(lt) => Some(*lt),
+			})
+	}
+
+	fn rust_lifetime_count(&self) -> usize {
+		self.rust_lifetime().map_or(0, |_| 1)
+	}
 }
 
 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,6 +95,15 @@ pub fn gen_boxed_class(c: &Class, opencv_version: &str) -> String {
 	const_methods.extend(more_const_methods);
 	mut_methods.extend(more_mut_methods);
 
+	let lt = c.rust_lifetime();
+	let rust_decl_lt = lt.map_or_else(|| "".to_string(), |lt| format!("<{}>", lt.to_explicit()));
+	let rust_decl_for_lt = lt.map_or_else(|| "".to_string(), |lt| format!(": for <{}>", lt.to_explicit()));
+	let rust_elided_lt = lt.map_or_else(|| "".to_string(), |_| "<'_>".to_string());
+	let rust_phantom_ref = lt.map_or_else(
+		|| "".to_string(),
+		|lt| format!("_d: PhantomData<&{} mut ()>,", lt.to_explicit()),
+	);
+
 	let type_ref = c.type_ref();
 	let bases = c.bases();
 
@@ -128,7 +143,8 @@ 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)),
 				(
@@ -164,6 +180,10 @@ pub fn gen_boxed_class(c: &Class, opencv_version: &str) -> String {
 		("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",
@@ -179,7 +199,7 @@ pub fn gen_boxed_class(c: &Class, opencv_version: &str) -> String {
 		("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),
 	]))
 }
@@ -296,7 +316,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("");
@@ -310,6 +336,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),
 		]))

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

@@ -15,6 +15,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};
 
@@ -221,6 +222,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);
@@ -231,6 +233,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 {
@@ -244,6 +247,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!(
@@ -312,8 +316,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() {

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

@@ -5,12 +5,18 @@ use crate::renderer::TypeRefRenderer;
 use crate::type_ref::{
 	Constness, CppNameStyle, Dir, ExternDir, FishStyle, NameStyle, StrType, TemplateArg, TypeRef, TypeRefDesc, TypeRefKind,
 };
+use crate::writer::rust_native::class::ClassExt;
 use crate::writer::rust_native::element::RustElement;
 use crate::writer::rust_native::function::FunctionExt;
 use crate::writer::rust_native::type_ref::{Lifetime, NullabilityExt, TypeRefExt};
 use crate::{settings, CowMapBorrowedExt, Element, IteratorExt};
 
-fn render_rust_tpl<'a>(renderer: impl TypeRefRenderer<'a>, type_ref: &TypeRef, fish_style: FishStyle) -> String {
+fn render_rust_tpl<'a>(
+	renderer: impl TypeRefRenderer<'a>,
+	type_ref: &TypeRef,
+	lifetime: Lifetime,
+	fish_style: FishStyle,
+) -> String {
 	let generic_types = type_ref.template_specialization_args();
 	if !generic_types.is_empty() {
 		let const_generics_implemented = type_ref
@@ -30,8 +36,13 @@ fn render_rust_tpl<'a>(renderer: impl TypeRefRenderer<'a>, type_ref: &TypeRef, f
 			}
 			TemplateArg::Unknown => None,
 		});
-		let generics = generic_types.join(", ");
+		let mut generics = generic_types.join(", ");
+		if lifetime.is_explicit() {
+			generics.insert_str(0, &format!("{lifetime}, "));
+		}
 		format!("{constant_suffix}{fish}<{generics}>", fish = fish_style.rust_qual())
+	} else if lifetime.is_explicit() {
+		format!("{fish}<{lifetime}>", fish = fish_style.rust_qual())
 	} else {
 		"".to_string()
 	}
@@ -109,10 +120,11 @@ impl TypeRefRenderer<'_> for RustRenderer {
 				}
 				TypeRefKind::Class(cls) => {
 					let fish_style = self.name_style.turbo_fish_style();
+					let lifetime = cls.rust_lifetime().map_or(Lifetime::Elided, |_| self.lifetime);
 					format!(
 						"{name}{generic}",
 						name = cls.rust_name(self.name_style),
-						generic = render_rust_tpl(self, type_ref, fish_style),
+						generic = render_rust_tpl(self, type_ref, lifetime, fish_style),
 					)
 					.into()
 				}

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

@@ -1,11 +1,11 @@
-impl {{base_rust_full_const}} for {{rust_local}} {
+impl {{base_rust_full_const}} for {{rust_local}}{{rust_elided_lt}} {
 	#[inline] fn {{rust_as_raw_const}}(&self) -> {{base_rust_extern_const}} { self.as_raw() }
 }
 
-impl {{base_rust_full_mut}} for {{rust_local}} {
+impl {{base_rust_full_mut}} for {{rust_local}}{{rust_elided_lt}} {
 	#[inline] fn {{rust_as_raw_mut}}(&mut self) -> {{base_rust_extern_mut}} { self.as_raw_mut() }
 }
 
-boxed_ref! { {{rust_local}}, {{base_rust_full_const}}, {{rust_as_raw_const}}, {{base_rust_full_mut}}, {{rust_as_raw_mut}} }
+boxed_ref! { {{rust_local}}{{rust_elided_lt}}, {{base_rust_full_const}}, {{rust_as_raw_const}}, {{base_rust_full_mut}}, {{rust_as_raw_mut}} }
 
 

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

@@ -1,19 +1,20 @@
 {{doc_comment}}
 {{debug}}
-pub struct {{rust_local}} {
+pub struct {{rust_local}}{{rust_decl_lt}} {
 	ptr: {{rust_extern_mut}},
+	{{rust_phantom_ref}}
 }
 
-opencv_type_boxed! { {{rust_local}} }
+opencv_type_boxed! { {{rust_local}}{{rust_decl_lt}}{{rust_decl_for_lt}} }
 
-impl Drop for {{rust_local}} {
+impl Drop for {{rust_local}}{{rust_elided_lt}} {
 	#[inline]
 	fn drop(&mut self) {
 		unsafe { sys::{{extern_delete}}(self.as_raw_mut_{{rust_local}}()) };
 	}
 }
 
-unsafe impl Send for {{rust_local}} {}
+unsafe impl Send for {{rust_local}}{{rust_elided_lt}} {}
 
 {{impl}}
 {{traits}}

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

@@ -1,4 +1,4 @@
-impl {{rust_local}} {
+impl{{rust_decl_lt}} {{rust_local}}{{rust_decl_lt}} {
 	{{consts}}
 	{{inherent_methods}}
 }