Fix passing Option<Ptr<T>>

Author: twistedfall

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

@@ -147,7 +147,7 @@ impl RustNativeGeneratedElement for SmartPtr<'_, '_> {
 		let rust_as_raw_mut = type_ref.rust_as_raw_name(Constness::Mut);
 
 		let ctor = if gen_ctor(&pointee_kind) {
-			let extern_new = method_new(smartptr_class.clone(), type_ref, pointee_type.as_ref().clone()).identifier();
+			let extern_new = method_new(smartptr_class.clone(), type_ref.clone(), pointee_type.as_ref().clone()).identifier();
 			CTOR_TPL.interpolate(&HashMap::from([
 				("inner_rust_full", inner_rust_full.as_ref()),
 				("extern_new", &extern_new),
@@ -156,13 +156,15 @@ impl RustNativeGeneratedElement for SmartPtr<'_, '_> {
 			"".to_string()
 		};
 
+		let extern_new_null = method_new_null(smartptr_class.clone(), type_ref).identifier();
 		let extern_delete = FuncDesc::method_delete(smartptr_class).identifier();
 		TPL.interpolate(&HashMap::from([
 			("rust_localalias", rust_localalias.as_ref()),
 			("rust_as_raw_const", &rust_as_raw_const),
 			("rust_as_raw_mut", &rust_as_raw_mut),
 			("rust_full", &rust_full),
 			("inner_rust_full", &inner_rust_full),
+			("extern_new_null", &extern_new_null),
 			("extern_delete", &extern_delete),
 			("extern_get_inner_ptr", &extern_get_inner_ptr),
 			("extern_get_inner_ptr_mut", &extern_get_inner_ptr_mut),
@@ -197,6 +199,7 @@ fn extern_functions<'tu, 'ge>(ptr: &SmartPtr<'tu, 'ge>) -> Vec<Func<'tu, 'ge>> {
 		smartptr_class.clone(),
 		pointee_type.as_ref().clone().with_inherent_constness(Constness::Mut),
 	));
+	out.push(method_new_null(smartptr_class.clone(), type_ref.clone()));
 	out.push(FuncDesc::method_delete(smartptr_class.clone()));
 	if let Some(cls) = pointee_kind.as_class().filter(|cls| cls.kind().is_trait()) {
 		for base in all_bases(&cls) {
@@ -297,6 +300,21 @@ fn method_new<'tu, 'ge>(
 	)
 }
 
+fn method_new_null<'tu, 'ge>(smartptr_class: Class<'tu, 'ge>, smartptr_type_ref: TypeRef<'tu, 'ge>) -> Func<'tu, 'ge> {
+	Func::new_desc(
+		FuncDesc::new(
+			FuncKind::Constructor(smartptr_class),
+			Constness::Const,
+			ReturnKind::InfallibleNaked,
+			"new_null",
+			"<unused>",
+			[],
+			smartptr_type_ref,
+		)
+		.cpp_body(FuncCppBody::ManualCallReturn("return new {{ret_type}}();".into())),
+	)
+}
+
 fn method_cast_to_base<'tu, 'ge>(
 	smartptr_class: Class<'tu, 'ge>,
 	base_type_ref: TypeRef<'tu, 'ge>,

binding-generator/src/writer/rust_native/tpl/smart_ptr/rust.tpl.rs

@@ -2,7 +2,7 @@
 pub type {{rust_localalias}} = {{rust_full}};
 
 ptr_extern! { {{inner_rust_full}},
-	{{extern_delete}}, {{extern_get_inner_ptr}}, {{extern_get_inner_ptr_mut}}
+	{{extern_new_null}}, {{extern_delete}}, {{extern_get_inner_ptr}}, {{extern_get_inner_ptr_mut}}
 }
 
 {{ctor}}

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

@@ -73,9 +73,9 @@ impl TypeRefExt for TypeRef<'_, '_> {
 					RenderLane::Primitive(PrimitiveRenderLane::from_cpp_non_canonical(cpp, self.clone()))
 				}
 				TypeRefKind::Function(f) => RenderLane::Function(FunctionRenderLane::from_non_canonical_func(self.clone(), f)),
-				TypeRefKind::StdVector(_) | TypeRefKind::SmartPtr(_) | TypeRefKind::StdTuple(_) => {
-					RenderLane::CppPassByVoidPtr(CppPassByVoidPtrRenderLane::from_non_canonical(self.clone()))
-				}
+				TypeRefKind::StdVector(_) | TypeRefKind::SmartPtr(_) | TypeRefKind::StdTuple(_) => RenderLane::CppPassByVoidPtr(
+					CppPassByVoidPtrRenderLane::from_non_canonical_indirection(self.clone(), Indirection::None),
+				),
 				TypeRefKind::Array(elem, None) => {
 					if matches!(self.type_hint(), TypeRefTypeHint::Slice) && elem.kind().is_void() {
 						RenderLane::VoidSlice(VoidSliceRenderLane::from_canonical(canonical.into_owned()))
@@ -90,7 +90,10 @@ impl TypeRefExt for TypeRef<'_, '_> {
 				)),
 				TypeRefKind::RValueReference(inner) => {
 					if inner.kind().extern_pass_kind().is_by_void_ptr() {
-						RenderLane::CppPassByVoidPtr(CppPassByVoidPtrRenderLane::from_non_canonical(self.clone()))
+						RenderLane::CppPassByVoidPtr(CppPassByVoidPtrRenderLane::from_non_canonical_indirection(
+							self.clone(),
+							Indirection::None,
+						))
 					} else {
 						RenderLane::ByMove(ByMoveRenderLane::from_non_canonical(self.clone()))
 					}
@@ -130,9 +133,9 @@ impl TypeRefExt for TypeRef<'_, '_> {
 							enm,
 							indirection,
 						)),
-						kind if kind.extern_pass_kind().is_by_void_ptr() => {
-							RenderLane::CppPassByVoidPtr(CppPassByVoidPtrRenderLane::from_non_canonical(self.clone()))
-						}
+						kind if kind.extern_pass_kind().is_by_void_ptr() => RenderLane::CppPassByVoidPtr(
+							CppPassByVoidPtrRenderLane::from_non_canonical_indirection(self.clone(), indirection),
+						),
 						_ => RenderLane::Indirect(IndirectRenderLane::from_non_canonical_indirection(self.clone(), indirection)),
 					}
 				}

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

@@ -1,18 +1,22 @@
 use std::borrow::Cow;
 use std::borrow::Cow::{Borrowed, Owned};
 
-use super::{rust_arg_func_decl, rust_self_func_decl, RenderLaneTrait};
+use super::{rust_arg_func_decl, rust_self_func_decl, FunctionProps, Indirection, RenderLaneTrait};
 use crate::type_ref::{Constness, ExternDir, FishStyle, TypeRef};
-use crate::writer::rust_native::type_ref::{Lifetime, NullabilityExt, TypeRefExt};
+use crate::writer::rust_native::type_ref::{Lifetime, TypeRefExt};
 use crate::{CowMapBorrowedExt, CppNameStyle, NameStyle};
 
 pub struct CppPassByVoidPtrRenderLane<'tu, 'ge> {
 	non_canonical: TypeRef<'tu, 'ge>,
+	indirection: Indirection,
 }
 
 impl<'tu, 'ge> CppPassByVoidPtrRenderLane<'tu, 'ge> {
-	pub fn from_non_canonical(non_canonical: TypeRef<'tu, 'ge>) -> Self {
-		Self { non_canonical }
+	pub fn from_non_canonical_indirection(non_canonical: TypeRef<'tu, 'ge>, indirection: Indirection) -> Self {
+		Self {
+			non_canonical,
+			indirection,
+		}
 	}
 }
 
@@ -33,6 +37,22 @@ impl RenderLaneTrait for CppPassByVoidPtrRenderLane<'_, '_> {
 		)
 	}
 
+	fn rust_arg_pre_call(&self, name: &str, function_props: &FunctionProps) -> String {
+		let is_nullable = self.non_canonical.type_hint().nullability().is_nullable();
+		if is_nullable && self.non_canonical.source().kind().as_smart_ptr().is_some() {
+			let ref_spec = match self.indirection {
+				Indirection::Pointer | Indirection::Reference => "ref ",
+				Indirection::None => "",
+			};
+			format!(
+				"smart_ptr_option_arg!({safety}{ref_spec}{name})",
+				safety = function_props.safety.rust_block_safety_qual()
+			)
+		} else {
+			"".to_string()
+		}
+	}
+
 	fn rust_arg_func_call(&self, name: &str) -> String {
 		rust_arg_func_call(&self.non_canonical, name)
 	}
@@ -71,12 +91,8 @@ impl RenderLaneTrait for CppPassByVoidPtrRenderLane<'_, '_> {
 }
 
 fn rust_arg_func_call(type_ref: &TypeRef, name: &str) -> String {
-	let src_typ = type_ref.source();
-	let constness = type_ref.constness();
-	let by_ptr = format!("{name}.{as_raw}()", as_raw = src_typ.rust_as_raw_name(constness));
-	type_ref
-		.type_hint()
-		.nullability()
-		.rust_wrap_nullable_func_call(name, by_ptr.into(), constness)
-		.into_owned()
+	format!(
+		"{name}.{as_raw}()",
+		as_raw = type_ref.source().rust_as_raw_name(type_ref.constness())
+	)
 }

src/manual/core/ptr.rs

@@ -35,6 +35,13 @@ where
 		unsafe { Self::from_raw(Self::extern_new(val.opencv_into_extern())) }
 	}
 
+	/// Create a new `Ptr` which points to `NULL`
+	///
+	/// Not generally useful, mostly for internal use.
+	pub unsafe fn new_null() -> Self {
+		unsafe { Self::from_raw(Self::extern_new_null()) }
+	}
+
 	/// Get raw pointer to the inner object
 	pub fn inner_as_raw(&self) -> *const c_void {
 		unsafe { self.extern_inner_as_ptr() }

src/manual/core/ptr/ptr_extern.rs

@@ -5,6 +5,8 @@ use crate::{extern_receive, extern_send};
 
 #[doc(hidden)]
 pub trait PtrExtern {
+	#[doc(hidden)]
+	unsafe fn extern_new_null() -> *mut c_void;
 	#[doc(hidden)]
 	unsafe fn extern_delete(&mut self);
 	#[doc(hidden)]
@@ -24,8 +26,13 @@ pub trait PtrExternCtor<T: OpenCVTypeExternContainerMove> {
 #[doc(hidden)]
 #[macro_export]
 macro_rules! ptr_extern {
-	($type: ty, $extern_delete: ident, $extern_inner_as_ptr: ident, $extern_inner_as_ptr_mut: ident $(,)?) => {
+	($type: ty, $extern_new_null: ident, $extern_delete: ident, $extern_inner_as_ptr: ident, $extern_inner_as_ptr_mut: ident $(,)?) => {
 		impl $crate::core::PtrExtern for $crate::core::Ptr<$type> {
+			#[inline]
+			unsafe fn extern_new_null() -> *mut ::std::ffi::c_void {
+				$crate::sys::$extern_new_null()
+			}
+
 			#[inline]
 			unsafe fn extern_delete(&mut self) {
 				$crate::sys::$extern_delete(self.as_raw_mut())

src/templ.rs

@@ -97,6 +97,31 @@ macro_rules! string_array_arg_mut {
 	};
 }
 
+macro_rules! smart_ptr_option_arg {
+	(unsafe ref $name: ident) => {
+		let null = if $name.is_none() {
+			Some(unsafe { $crate::core::Ptr::new_null() })
+		} else {
+			None
+		};
+		let $name = $name.or(null.as_ref()).expect("Nullability should have been checked");
+	};
+	(unsafe $name: ident) => {
+		let $name = $name.unwrap_or_else(|| unsafe { $crate::core::Ptr::new_null() });
+	};
+	(ref $name: ident) => {
+		let null = if $name.is_none() {
+			Some($crate::core::Ptr::new_null())
+		} else {
+			None
+		};
+		let $name = $name.or(null.as_ref()).expect("Nullability should have been checked");
+	};
+	($name: ident) => {
+		let $name = $name.unwrap_or_else(|| $crate::core::Ptr::new_null());
+	};
+}
+
 macro_rules! return_send {
 	(via $name: ident) => {
 		let mut $name = ::std::mem::MaybeUninit::uninit();

tests/marshalling.rs

@@ -279,3 +279,29 @@ fn string_array() -> Result<()> {
 	assert_eq!("b", parser.get_str("a", true)?);
 	Ok(())
 }
+
+#[test]
+fn smart_ptr_optional() -> Result<()> {
+	#![cfg(ocvrs_has_module_calib3d)]
+
+	use opencv::calib3d;
+	use opencv::core::{Point2f, Size, Vector};
+
+	let mut centers = Vector::<Point2f>::new();
+	for i in 0..4 {
+		for j in 0..4 {
+			centers.push((i as f32 * 100.0, j as f32 * 100.0).into());
+		}
+	}
+
+	let mut out_centers = Vector::<Point2f>::new();
+	let r = calib3d::find_circles_grid_1(
+		&centers,
+		Size::new(4, 4),
+		&mut out_centers,
+		calib3d::CALIB_CB_SYMMETRIC_GRID,
+		None,
+	);
+	assert!(matches!(r, Ok(true)));
+	Ok(())
+}