Introduce the ExplicitLifetype type ref hint

Author: twistedfall

binding-generator/src/type_ref/types.rs

@@ -34,6 +34,8 @@ pub enum TypeRefTypeHint {
 	/// Make sure to pass TraitClass as a concrete type, not as a trait object, it's used for property setters as we don't want
 	/// to be able to use `BoxedRef` there.
 	TraitClassConcrete,
+	/// References in Rust will get an indicated lifetime instead of the implied one
+	ExplicitLifetime(Lifetime),
 }
 
 impl TypeRefTypeHint {
@@ -51,41 +53,60 @@ impl TypeRefTypeHint {
 		match self {
 			Self::Nullable => Self::None,
 			Self::NullableSlice => Self::Slice,
-			recursable => recursable,
+			Self::None
+			| Self::Slice
+			| Self::LenForSlice(_, _)
+			| Self::StringAsBytes(_)
+			| Self::CharAsRustChar
+			| Self::CharPtrSingleChar
+			| Self::PrimitivePtrAsRaw
+			| Self::AddArrayLength(_)
+			| Self::BoxedAsRef(_, _, _)
+			| Self::TraitClassConcrete
+			| Self::ExplicitLifetime(_) => self.clone(),
 		}
 	}
 
 	pub fn nullability(&self) -> Nullability {
 		match self {
-			TypeRefTypeHint::Nullable | TypeRefTypeHint::NullableSlice => Nullability::Nullable,
-			TypeRefTypeHint::None
-			| TypeRefTypeHint::Slice
-			| TypeRefTypeHint::LenForSlice(_, _)
-			| TypeRefTypeHint::StringAsBytes(_)
-			| TypeRefTypeHint::CharAsRustChar
-			| TypeRefTypeHint::CharPtrSingleChar
-			| TypeRefTypeHint::PrimitivePtrAsRaw
-			| TypeRefTypeHint::AddArrayLength(_)
-			| TypeRefTypeHint::BoxedAsRef(_, _, _)
-			| TypeRefTypeHint::TraitClassConcrete => Nullability::NotNullable,
+			Self::Nullable | Self::NullableSlice => Nullability::Nullable,
+			Self::None
+			| Self::Slice
+			| Self::LenForSlice(_, _)
+			| Self::StringAsBytes(_)
+			| Self::CharAsRustChar
+			| Self::CharPtrSingleChar
+			| Self::PrimitivePtrAsRaw
+			| Self::AddArrayLength(_)
+			| Self::BoxedAsRef(_, _, _)
+			| Self::TraitClassConcrete
+			| Self::ExplicitLifetime(_) => Nullability::NotNullable,
 		}
 	}
 
 	pub fn as_slice_len(&self) -> Option<(&[String], usize)> {
-		if let TypeRefTypeHint::LenForSlice(ptr_arg, len_div) = self {
+		if let Self::LenForSlice(ptr_arg, len_div) = self {
 			Some((ptr_arg, *len_div))
 		} else {
 			None
 		}
 	}
 
 	pub fn as_boxed_as_ref(&self) -> Option<(Constness, &'static str, Lifetime)> {
-		if let TypeRefTypeHint::BoxedAsRef(constness, cpp_name, lifetime) = self {
+		if let Self::BoxedAsRef(constness, cpp_name, lifetime) = self {
 			Some((*constness, cpp_name, *lifetime))
 		} else {
 			None
 		}
 	}
+
+	pub fn as_explicit_lifetime(&self) -> Option<Lifetime> {
+		if let Self::ExplicitLifetime(lifetime) = self {
+			Some(*lifetime)
+		} else {
+			None
+		}
+	}
 }
 
 #[derive(Clone, Copy, Debug)]

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

@@ -237,7 +237,8 @@ impl RustNativeGeneratedElement for Func<'_, '_> {
 		};
 		for (name, arg) in &args {
 			let arg_type_ref = arg.type_ref();
-			let arg_as_slice_len = arg_type_ref.type_hint().as_slice_len();
+			let arg_type_hint = arg_type_ref.type_hint();
+			let arg_as_slice_len = arg_type_hint.as_slice_len();
 			let arg_kind = arg_type_ref.kind();
 			let render_lane = arg_type_ref.render_lane();
 			let render_lane = render_lane.to_dyn();
@@ -257,7 +258,9 @@ impl RustNativeGeneratedElement for Func<'_, '_> {
 				if !arg_as_slice_len.is_some() {
 					let lt = boxed_ref_arg
 						.filter(|(_, boxed_arg_name, _)| *boxed_arg_name == name)
-						.map_or(Lifetime::Elided, |(_, _, lt)| lt);
+						.map(|(_, _, lt)| lt)
+						.or_else(|| arg_type_hint.as_explicit_lifetime())
+						.unwrap_or(Lifetime::Elided);
 					decl_args.push(render_lane.rust_arg_func_decl(name, lt).into());
 				}
 				pre_post_arg_handle(render_lane.rust_arg_pre_call(name, &function_props), &mut pre_call_args);

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

@@ -281,6 +281,6 @@ impl TypeRefRenderer<'_> for RustReturnRenderer {
 	}
 
 	fn recurse(&self) -> Self::Recursed {
-		RustRenderer::new(NameStyle::Reference(self.turbo_fish_style), Lifetime::Elided)
+		RustRenderer::new(NameStyle::Reference(self.turbo_fish_style), self.lifetime)
 	}
 }

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

@@ -218,7 +218,8 @@ impl TypeRefExt for TypeRef<'_, '_> {
 	}
 
 	fn rust_name(&self, name_style: NameStyle) -> Cow<str> {
-		self.rust_name_ext(name_style, Lifetime::Elided)
+		let lt = self.type_hint().as_explicit_lifetime().unwrap_or(Lifetime::Elided);
+		self.rust_name_ext(name_style, lt)
 	}
 
 	fn rust_name_ext(&self, name_style: NameStyle, lifetime: Lifetime) -> Cow<str> {