Use a uniform approach to sealing traits

Author: adamreichold

src/array_like.rs

@@ -10,13 +10,18 @@ use pyo3::{
 };
 
 use crate::array::PyArrayMethods;
-use crate::sealed::Sealed;
 use crate::{get_array_module, Element, IntoPyArray, PyArray, PyReadonlyArray};
 
 pub trait Coerce: Sealed {
     const VAL: bool;
 }
 
+mod sealed {
+    pub trait Sealed {}
+}
+
+use sealed::Sealed;
+
 /// Marker type to indicate that the element type received via [`PyArrayLike`] must match the specified type exactly.
 #[derive(Debug)]
 pub struct TypeMustMatch;

src/convert.rs

@@ -9,7 +9,6 @@ use crate::array::{PyArray, PyArrayMethods};
 use crate::dtype::Element;
 use crate::error::MAX_DIMENSIONALITY_ERR;
 use crate::npyffi::{self, npy_intp};
-use crate::sealed::Sealed;
 use crate::slice_container::PySliceContainer;
 
 /// Conversion trait from owning Rust types into [`PyArray`].
@@ -273,6 +272,12 @@ pub trait ToNpyDims: Dimension + Sealed {
     }
 }
 
+mod sealed {
+    pub trait Sealed {}
+}
+
+use sealed::Sealed;
+
 impl<D> ToNpyDims for D where D: Dimension {}
 
 /// Trait implemented by types that can be used to index an array.

src/dtype.rs

@@ -364,7 +364,7 @@ impl PyArrayDescr {
 
 /// Implementation of functionality for [`PyArrayDescr`].
 #[doc(alias = "PyArrayDescr")]
-pub trait PyArrayDescrMethods<'py>: sealed::Sealed {
+pub trait PyArrayDescrMethods<'py>: Sealed {
     /// Returns `self` as `*mut PyArray_Descr`.
     fn as_dtype_ptr(&self) -> *mut PyArray_Descr;
 
@@ -553,6 +553,12 @@ pub trait PyArrayDescrMethods<'py>: sealed::Sealed {
     fn get_field(&self, name: &str) -> PyResult<(Bound<'py, PyArrayDescr>, usize)>;
 }
 
+mod sealed {
+    pub trait Sealed {}
+}
+
+use sealed::Sealed;
+
 impl<'py> PyArrayDescrMethods<'py> for Bound<'py, PyArrayDescr> {
     fn as_dtype_ptr(&self) -> *mut PyArray_Descr {
         self.as_ptr() as _
@@ -632,13 +638,7 @@ impl<'py> PyArrayDescrMethods<'py> for Bound<'py, PyArrayDescr> {
     }
 }
 
-mod sealed {
-    use super::PyArrayDescr;
-
-    pub trait Sealed {}
-
-    impl Sealed for pyo3::Bound<'_, PyArrayDescr> {}
-}
+impl Sealed for Bound<'_, PyArrayDescr> {}
 
 /// Represents that a type can be an element of `PyArray`.
 ///

src/lib.rs

@@ -130,10 +130,6 @@ mod doctest {
     doc_comment!(include_str!("../README.md"), readme);
 }
 
-mod sealed {
-    pub trait Sealed {}
-}
-
 #[cold]
 #[inline(always)]
 fn cold() {}

src/untyped_array.rs

@@ -258,7 +258,7 @@ impl PyUntypedArray {
 
 /// Implementation of functionality for [`PyUntypedArray`].
 #[doc(alias = "PyUntypedArray")]
-pub trait PyUntypedArrayMethods<'py>: sealed::Sealed {
+pub trait PyUntypedArrayMethods<'py>: Sealed {
     /// Returns a raw pointer to the underlying [`PyArrayObject`][npyffi::PyArrayObject].
     fn as_array_ptr(&self) -> *mut npyffi::PyArrayObject;
 
@@ -423,6 +423,12 @@ pub trait PyUntypedArrayMethods<'py>: sealed::Sealed {
     }
 }
 
+mod sealed {
+    pub trait Sealed {}
+}
+
+use sealed::Sealed;
+
 fn check_flags(obj: &npyffi::PyArrayObject, flags: i32) -> bool {
     obj.flags & flags != 0
 }
@@ -441,6 +447,8 @@ impl<'py> PyUntypedArrayMethods<'py> for Bound<'py, PyUntypedArray> {
     }
 }
 
+impl Sealed for Bound<'_, PyUntypedArray> {}
+
 // We won't be able to provide a `Deref` impl from `Bound<'_, PyArray<T, D>>` to
 // `Bound<'_, PyUntypedArray>`, so this seems to be the next best thing to do
 impl<'py, T, D> PyUntypedArrayMethods<'py> for Bound<'py, PyArray<T, D>> {
@@ -455,11 +463,4 @@ impl<'py, T, D> PyUntypedArrayMethods<'py> for Bound<'py, PyArray<T, D>> {
     }
 }
 
-mod sealed {
-    use super::{PyArray, PyUntypedArray};
-
-    pub trait Sealed {}
-
-    impl Sealed for pyo3::Bound<'_, PyUntypedArray> {}
-    impl<T, D> Sealed for pyo3::Bound<'_, PyArray<T, D>> {}
-}
+impl<T, D> Sealed for Bound<'_, PyArray<T, D>> {}