Bump MSRV to 1.88 and use 2024 edition

Author: Luthaf

.github/workflows/tests.yml

@@ -15,7 +15,7 @@ jobs:
     strategy:
       matrix:
         toolchain:
-          - "1.74"
+          - "1.88"
           - stable
           - nightly
     steps:
@@ -27,19 +27,6 @@ jobs:
       - name: Setup sccache-cache
         uses: mozilla-actions/sccache-action@v0.0.9
 
-      # MSRV backfill: pyo3 0.28 requires rustc >=1.83 and pyo3 0.27 is
-      # the last line with MSRV 1.74. dlpk accepts `>=0.27, <0.29`, so we
-      # pin the pyo3 stack to the 0.27 line for the 1.74 job only. Stable
-      # and nightly resolve to 0.28 naturally.
-      - name: Pin pyo3 to 0.27 on MSRV toolchain
-        if: matrix.toolchain == '1.74'
-        run: |
-          cargo update -p pyo3 --precise 0.27.2
-          cargo update -p pyo3-build-config --precise 0.27.2
-          cargo update -p pyo3-macros --precise 0.27.2
-          cargo update -p pyo3-macros-backend --precise 0.27.2
-          cargo update -p pyo3-ffi --precise 0.27.2
-
       - name: Run tests
         env:
           SCCACHE_GHA_ENABLED: "true"

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "dlpk"
 version = "0.3.1"
-edition = "2021"
-rust-version = "1.74"
+edition = "2024"
+rust-version = "1.88"
 license = "MIT OR Apache-2.0"
 
 authors = [
@@ -18,16 +18,9 @@ keywords = ["dlpack", "deep-learning", "machine-learning"]
 
 [dependencies]
 ndarray = { version = "0.17", optional = true }
-# Accept either 0.27 or 0.28 so downstream crates on either line can take
-# dlpk as a dep without forcing a pyo3 version conflict. 0.28 has MSRV 1.83
-# while 0.27 keeps MSRV 1.74; the MSRV CI job uses `cargo update --precise`
-# to pin to 0.27.
-pyo3 = { version = ">=0.27, <0.29", optional = true }
+pyo3 = { version = "0.29", optional = true }
 ouroboros = { version = "0.18", optional = true }
-
-# 2.3 has MSRV 1.7.0
-# 2.5 has MSRV 1.81
-half = { version = "<2.5", optional = true }
+half = { version = "2.7", optional = true }
 
 [features]
 ndarray = ["dep:ndarray"]

src/lib.rs

@@ -232,12 +232,15 @@ impl std::fmt::Debug for DLPackTensor {
             flags_strings.join(" | ")
         };
 
+        let debug_tensor = unsafe {
+            DLTensorDebug(&self.raw.as_ref().dl_tensor)
+        };
         f.debug_struct("DLPackTensor")
             .field("version", unsafe { &self.raw.as_ref().version })
             .field("manager_ctx", unsafe { &self.raw.as_ref().manager_ctx })
             .field("deleter", unsafe { &self.raw.as_ref().deleter })
             .field("flags", &flags_string)
-            .field("dl_tensor", unsafe { &DLTensorDebug(&self.raw.as_ref().dl_tensor) })
+            .field("dl_tensor", &debug_tensor)
             .finish()
     }
 }
@@ -262,7 +265,9 @@ impl DLPackTensor {
     pub unsafe fn from_ptr(tensor: *mut sys::DLManagedTensorVersioned) -> DLPackTensor {
         let tensor = NonNull::new(tensor).expect("DLManagedTensorVersioned pointer is null");
 
-        return DLPackTensor::from_raw(tensor);
+        return unsafe {
+            DLPackTensor::from_raw(tensor)
+        };
     }
 
     /// Create a `DLPackTensor` from a non-null pointer to
@@ -272,15 +277,18 @@ impl DLPackTensor {
     ///
     /// The same safety requirements as `from_ptr` apply.
     pub unsafe fn from_raw(tensor: NonNull<sys::DLManagedTensorVersioned>) -> DLPackTensor {
-        if tensor.as_ref().version.major != sys::DLPACK_MAJOR_VERSION {
+        let tensor_ref = unsafe { tensor.as_ref() };
+        if tensor_ref.version.major != sys::DLPACK_MAJOR_VERSION {
             // from the spec, we need to call the deleter here (and it is the
             // only thing we can do)
-            if let Some(deleter) = tensor.as_ref().deleter {
-                deleter(tensor.as_ptr());
+            if let Some(deleter) = tensor_ref.deleter {
+                unsafe {
+                    deleter(tensor.as_ptr());
+                }
             }
             panic!(
                 "Incompatible DLPack version, got {}, but this code only supports version {}",
-                tensor.as_ref().version.major, sys::DLPACK_MAJOR_VERSION
+                tensor_ref.version.major, sys::DLPACK_MAJOR_VERSION
             );
         }
         return DLPackTensor{

src/ndarray/mod.rs

@@ -403,12 +403,14 @@ struct ManagerContext<T> {
 }
 
 unsafe extern "C" fn deleter_fn<T>(tensor: *mut sys::DLManagedTensorVersioned) {
-    // Reconstruct the box and drop it, freeing the memory.
-    let ctx = (*tensor).manager_ctx.cast::<ManagerContext<T>>();
-    let _ = Box::from_raw(ctx);
+    unsafe {
+        // Reconstruct the box and drop it, freeing the memory.
+        let ctx = (*tensor).manager_ctx.cast::<ManagerContext<T>>();
+        let _ = Box::from_raw(ctx);
 
-    // also drop the tensor itself
-    let _ = Box::from_raw(tensor);
+        // also drop the tensor itself
+        let _ = Box::from_raw(tensor);
+    }
 }
 
 impl<T, D> TryFrom<Array<T, D>> for DLPackTensor
@@ -801,7 +803,9 @@ mod tests {
     }
 
     unsafe extern "C" fn box_deleter(tensor: *mut sys::DLManagedTensorVersioned) {
-        let _ = Box::from_raw(tensor);
+        unsafe {
+            let _ = Box::from_raw(tensor);
+        }
     }
 
     #[test]

src/ndarray/sync.rs

@@ -46,21 +46,25 @@ struct RwLockCtxRead<Array> where Array: 'static {
 }
 
 unsafe extern "C" fn rwlock_write_deleter_fn<T>(tensor: *mut sys::DLManagedTensorVersioned) where T: 'static {
-    // Reconstruct the box and drop it, freeing the memory.
-    let ctx = (*tensor).manager_ctx.cast::<RwLockCtxWrite<T>>();
-    let _ = Box::from_raw(ctx);
+    unsafe {
+        // Reconstruct the box and drop it, freeing the memory.
+        let ctx = (*tensor).manager_ctx.cast::<RwLockCtxWrite<T>>();
+        let _ = Box::from_raw(ctx);
 
-    // also drop the tensor itself
-    let _ = Box::from_raw(tensor);
+        // also drop the tensor itself
+        let _ = Box::from_raw(tensor);
+    }
 }
 
 unsafe extern "C" fn rwlock_read_deleter_fn<T>(tensor: *mut sys::DLManagedTensorVersioned) where T: 'static {
-    // Reconstruct the box and drop it, freeing the memory.
-    let ctx = (*tensor).manager_ctx.cast::<RwLockCtxRead<T>>();
-    let _ = Box::from_raw(ctx);
+    unsafe {
+        // Reconstruct the box and drop it, freeing the memory.
+        let ctx = (*tensor).manager_ctx.cast::<RwLockCtxRead<T>>();
+        let _ = Box::from_raw(ctx);
 
-    // also drop the tensor itself
-    let _ = Box::from_raw(tensor);
+        // also drop the tensor itself
+        let _ = Box::from_raw(tensor);
+    }
 }
 
 impl<T, D> TryFrom<ReadWrite<Arc<RwLock<Array<T, D>>>>> for DLPackTensor
@@ -227,12 +231,14 @@ struct MutexCtx<Array> where Array: 'static {
 }
 
 unsafe extern "C" fn mutex_deleter_fn<T>(tensor: *mut sys::DLManagedTensorVersioned) where T: 'static {
-    // Reconstruct the box and drop it, freeing the memory.
-    let ctx = (*tensor).manager_ctx.cast::<MutexCtx<T>>();
-    let _ = Box::from_raw(ctx);
+    unsafe {
+        // Reconstruct the box and drop it, freeing the memory.
+        let ctx = (*tensor).manager_ctx.cast::<MutexCtx<T>>();
+        let _ = Box::from_raw(ctx);
 
-    // also drop the tensor itself
-    let _ = Box::from_raw(tensor);
+        // also drop the tensor itself
+        let _ = Box::from_raw(tensor);
+    }
 }
 
 impl<T, D> TryFrom<Arc<Mutex<Array<T, D>>>> for DLPackTensor

src/pyo3.rs

@@ -156,10 +156,8 @@ impl PyDLPack {
         // we can ignore `max_version`, the consumer is supposed to check it again
         // anyway
 
-        if let Some(device) = dl_device {
-            if device.ne(self.__dlpack_device__(py)?)? {
-                return Err(PyErr::new::<PyBufferError, _>("unsupported `dl_device`"));
-            }
+        if let Some(device) = dl_device && device.ne(self.__dlpack_device__(py)?)? {
+            return Err(PyErr::new::<PyBufferError, _>("unsupported `dl_device`"));
         }
 
         if copy.is_some() {
@@ -279,23 +277,25 @@ impl<'py> TryFrom<Bound<'py, PyCapsule>> for DLPackTensorRef<'py> {
 }
 
 unsafe extern "C" fn rust_capsule_deleter(object: *mut pyo3::ffi::PyObject) {
-    if pyo3::ffi::PyCapsule_IsValid(object, USED_DLTENSOR_VERSIONED_NAME.as_ptr()) == 1 {
-        // All good, the data was already transfered
-        return;
-    }
+    unsafe {
+        if pyo3::ffi::PyCapsule_IsValid(object, USED_DLTENSOR_VERSIONED_NAME.as_ptr()) == 1 {
+            // All good, the data was already transfered
+            return;
+        }
 
-    if !pyo3::ffi::PyCapsule_IsValid(object, DLTENSOR_VERSIONED_NAME.as_ptr()) == 1 {
-        // we got a bad capsule, send a warning
-        pyo3::ffi::PyErr_WriteUnraisable(object);
-        return;
-    }
+        if !pyo3::ffi::PyCapsule_IsValid(object, DLTENSOR_VERSIONED_NAME.as_ptr()) == 1 {
+            // we got a bad capsule, send a warning
+            pyo3::ffi::PyErr_WriteUnraisable(object);
+            return;
+        }
 
-    let ptr = pyo3::ffi::PyCapsule_GetPointer(object, DLTENSOR_VERSIONED_NAME.as_ptr());
+        let ptr = pyo3::ffi::PyCapsule_GetPointer(object, DLTENSOR_VERSIONED_NAME.as_ptr());
 
-    // PyCapsule_IsValid checks the the pointer is not null
-    let tensor = NonNull::new(ptr.cast::<DLManagedTensorVersioned>())
-        .expect("the capsule should be non-null");
-    std::mem::drop(DLPackTensor::from_raw(tensor));
+        // PyCapsule_IsValid checks the the pointer is not null
+        let tensor = NonNull::new(ptr.cast::<DLManagedTensorVersioned>())
+            .expect("the capsule should be non-null");
+        std::mem::drop(DLPackTensor::from_raw(tensor));
+    }
 }
 
 impl TryFrom<DLPackTensor> for PyDLPack {

src/sync.rs

@@ -38,12 +38,14 @@ struct MutexCtx<T> where T: 'static {
 }
 
 unsafe extern "C" fn mutex_deleter_fn<T>(tensor: *mut sys::DLManagedTensorVersioned) where T: 'static {
-    // Reconstruct the box and drop it, freeing the memory.
-    let ctx = (*tensor).manager_ctx.cast::<MutexCtx<T>>();
-    let _ = Box::from_raw(ctx);
+    unsafe {
+        // Reconstruct the box and drop it, freeing the memory.
+        let ctx = (*tensor).manager_ctx.cast::<MutexCtx<T>>();
+        let _ = Box::from_raw(ctx);
 
-    // also drop the tensor itself
-    let _ = Box::from_raw(tensor);
+        // also drop the tensor itself
+        let _ = Box::from_raw(tensor);
+    }
 }
 
 impl<T> TryFrom<Arc<Mutex<Vec<T>>>> for DLPackTensor where T: GetDLPackDataType + 'static {
@@ -132,21 +134,25 @@ struct RwLockCtxWrite<T> where T: 'static {
 }
 
 unsafe extern "C" fn rwlock_read_deleter_fn<T>(tensor: *mut sys::DLManagedTensorVersioned) where T: 'static {
-    // Reconstruct the box and drop it, freeing the memory.
-    let ctx = (*tensor).manager_ctx.cast::<RwLockCtxRead<T>>();
-    let _ = Box::from_raw(ctx);
+    unsafe {
+        // Reconstruct the box and drop it, freeing the memory.
+        let ctx = (*tensor).manager_ctx.cast::<RwLockCtxRead<T>>();
+        let _ = Box::from_raw(ctx);
 
-    // also drop the tensor itself
-    let _ = Box::from_raw(tensor);
+        // also drop the tensor itself
+        let _ = Box::from_raw(tensor);
+    }
 }
 
 unsafe extern "C" fn rwlock_write_deleter_fn<T>(tensor: *mut sys::DLManagedTensorVersioned) where T: 'static {
-    // Reconstruct the box and drop it, freeing the memory.
-    let ctx = (*tensor).manager_ctx.cast::<RwLockCtxWrite<T>>();
-    let _ = Box::from_raw(ctx);
+    unsafe {
+        // Reconstruct the box and drop it, freeing the memory.
+        let ctx = (*tensor).manager_ctx.cast::<RwLockCtxWrite<T>>();
+        let _ = Box::from_raw(ctx);
 
-    // also drop the tensor itself
-    let _ = Box::from_raw(tensor);
+        // also drop the tensor itself
+        let _ = Box::from_raw(tensor);
+    }
 }
 
 impl<T> TryFrom<ReadWrite<Arc<RwLock<Vec<T>>>>> for DLPackTensor where T: GetDLPackDataType + 'static {

src/vec.rs

@@ -159,12 +159,14 @@ struct ManagerContext<T> {
 }
 
 unsafe extern "C" fn deleter_fn<T>(tensor: *mut sys::DLManagedTensorVersioned) {
-    // Reconstruct the box and drop it, freeing the memory.
-    let ctx = (*tensor).manager_ctx.cast::<ManagerContext<T>>();
-    let _ = Box::from_raw(ctx);
+    unsafe {
+        // Reconstruct the box and drop it, freeing the memory.
+        let ctx = (*tensor).manager_ctx.cast::<ManagerContext<T>>();
+        let _ = Box::from_raw(ctx);
 
-    // also drop the tensor itself
-    let _ = Box::from_raw(tensor);
+        // also drop the tensor itself
+        let _ = Box::from_raw(tensor);
+    }
 }
 
 macro_rules! impl_try_from {
@@ -316,7 +318,9 @@ mod tests {
     }
 
     unsafe extern "C" fn box_deleter(tensor: *mut sys::DLManagedTensorVersioned) {
-        let _ = Box::from_raw(tensor);
+        unsafe {
+            let _ = Box::from_raw(tensor);
+        }
     }
 
     #[test]