Merge pull request #1 from Robzz/fix/broken-tests

fix: fix broken tests and update thiserror dependency

Author: Robzz

Cargo.toml

@@ -16,4 +16,4 @@ members = ["./recast-sys"]
 [dependencies]
 cxx = "1.0"
 recast-sys = { path = "./recast-sys", default-features = false }
-thiserror = "1.0"
+thiserror = "2.0"

src/lib.rs

@@ -6,6 +6,8 @@ pub mod recast;
 
 mod macros;
 
+use std::ptr::NonNull;
+
 #[cfg(feature = "detour")]
 use detour::Error as DetourError;
 #[cfg(feature = "recast")]
@@ -34,3 +36,21 @@ where
     }
     Ok(ptr)
 }
+
+fn slice_from_raw_parts_or_dangling<'a, T>(data: *const T, len: usize) -> &'a [T] {
+    if data.is_null() {
+        unsafe { std::slice::from_raw_parts(NonNull::dangling().as_ptr(), 0usize) }
+    }
+    else {
+        unsafe { std::slice::from_raw_parts(data, len) }
+    }
+}
+
+fn slice_from_raw_parts_mut_or_dangling<'a, T>(data: *mut T, len: usize) -> &'a mut [T] {
+    if data.is_null() {
+        unsafe { std::slice::from_raw_parts_mut(NonNull::dangling().as_ptr(), 0usize) }
+    }
+    else {
+        unsafe { std::slice::from_raw_parts_mut(data, len) }
+    }
+}

src/recast/poly_mesh.rs

@@ -1,44 +1,48 @@
+use std::ptr::{self, NonNull};
+
 #[cfg(feature = "detour")]
 use recast_sys::ffi::detour::NavMeshCreateParams;
 
+use crate::{slice_from_raw_parts_mut_or_dangling, slice_from_raw_parts_or_dangling};
+
 use super::PolyMesh;
 
 impl PolyMesh {
     pub fn vertices(&self) -> &[u16] {
         let vertices_buffer = recast_sys::ffi::recast::poly_mesh_get_vertices(self.as_ref());
         let n_vertices = recast_sys::ffi::recast::poly_mesh_get_vertex_count(self.as_ref());
-        unsafe { std::slice::from_raw_parts(vertices_buffer, (n_vertices * 3) as usize) }
+        slice_from_raw_parts_or_dangling(vertices_buffer, (n_vertices * 3) as usize)
     }
 
     pub fn polygons(&self) -> &[u16] {
         let polygons_buffer = recast_sys::ffi::recast::poly_mesh_get_polys(self.as_ref());
         let n_polys = recast_sys::ffi::recast::poly_mesh_get_poly_count(self.as_ref());
         let n_vpp = recast_sys::ffi::recast::poly_mesh_max_vertex_count_per_poly(self.as_ref());
-        unsafe { std::slice::from_raw_parts(polygons_buffer, (n_polys * 2 * n_vpp) as usize) }
+        slice_from_raw_parts_or_dangling(polygons_buffer, (n_polys * 2 * n_vpp) as usize)
     }
 
     pub fn regions(&self) -> &[u16] {
         let regions_buffer = recast_sys::ffi::recast::poly_mesh_get_regions(self.as_ref());
         let n_polys = recast_sys::ffi::recast::poly_mesh_get_poly_count(self.as_ref());
-        unsafe { std::slice::from_raw_parts(regions_buffer, n_polys as usize) }
+        slice_from_raw_parts_or_dangling(regions_buffer, n_polys as usize)
     }
 
     pub fn flags(&self) -> &[u16] {
         let flags_buffer = recast_sys::ffi::recast::poly_mesh_get_flags(self.as_ref());
         let n_polys = recast_sys::ffi::recast::poly_mesh_get_poly_count(self.as_ref());
-        unsafe { std::slice::from_raw_parts(flags_buffer, n_polys as usize) }
+        slice_from_raw_parts_or_dangling(flags_buffer, n_polys as usize)
     }
 
     pub fn flags_mut(&mut self) -> &mut [u16] {
         let flags_buffer = recast_sys::ffi::recast::poly_mesh_get_flags_mut(self.pin_mut());
         let n_polys = recast_sys::ffi::recast::poly_mesh_get_poly_count(self.as_ref());
-        unsafe { std::slice::from_raw_parts_mut(flags_buffer, n_polys as usize) }
+        slice_from_raw_parts_mut_or_dangling(flags_buffer, n_polys as usize)
     }
 
     pub fn areas(&self) -> &[u8] {
         let areas_buffer = recast_sys::ffi::recast::poly_mesh_get_areas(self.as_ref());
         let n_polys = recast_sys::ffi::recast::poly_mesh_get_poly_count(self.as_ref());
-        unsafe { std::slice::from_raw_parts(areas_buffer, n_polys as usize) }
+        slice_from_raw_parts_or_dangling(areas_buffer, n_polys as usize)
     }
 }
 

src/recast/poly_mesh_detail.rs

@@ -1,20 +1,22 @@
+use crate::slice_from_raw_parts_or_dangling;
+
 impl super::PolyMeshDetail {
     pub fn meshes(&self) -> &[u32] {
         let meshes_buffer = recast_sys::ffi::recast::poly_mesh_detail_meshes(self.as_ref());
         let n_meshes = recast_sys::ffi::recast::poly_mesh_detail_num_meshes(self.as_ref());
-        unsafe { std::slice::from_raw_parts(meshes_buffer, (n_meshes * 4) as usize) }
+        slice_from_raw_parts_or_dangling(meshes_buffer, (n_meshes * 4) as usize)
     }
 
     pub fn vertices(&self) -> &[f32] {
         let vertices_buffer = recast_sys::ffi::recast::poly_mesh_detail_vertices(self.as_ref());
         let n_vertices = recast_sys::ffi::recast::poly_mesh_detail_num_vertices(self.as_ref());
-        unsafe { std::slice::from_raw_parts(vertices_buffer, (n_vertices * 3) as usize) }
+        slice_from_raw_parts_or_dangling(vertices_buffer, (n_vertices * 3) as usize)
     }
 
     pub fn triangles(&self) -> &[u8] {
         let triangles_buffer = recast_sys::ffi::recast::poly_mesh_detail_triangles(self.as_ref());
         let n_triangles = recast_sys::ffi::recast::poly_mesh_detail_num_triangles(self.as_ref());
-        unsafe { std::slice::from_raw_parts(triangles_buffer, (n_triangles * 4) as usize) }
+        slice_from_raw_parts_or_dangling(triangles_buffer, (n_triangles * 4) as usize)
     }
 }