Merge pull request #1092 from adamreichold/more-clippy-lints

Expand Clippy coverage to docs features and resolve more lints

Author: bluss

.github/workflows/ci.yml

@@ -75,5 +75,5 @@ jobs:
           toolchain: ${{ matrix.rust }}
           override: true
           components: clippy
-      - run: cargo clippy
+      - run: cargo clippy --features docs
 

src/array_serde.rs

@@ -276,17 +276,17 @@ where
 
         let _v = match v {
             Some(v) => v,
-            None => Err(de::Error::missing_field("v"))?,
+            None => return Err(de::Error::missing_field("v")),
         };
 
         let data = match data {
             Some(data) => data,
-            None => Err(de::Error::missing_field("data"))?,
+            None => return Err(de::Error::missing_field("data")),
         };
 
         let dim = match dim {
             Some(dim) => dim,
-            None => Err(de::Error::missing_field("dim"))?,
+            None => return Err(de::Error::missing_field("dim")),
         };
 
         if let Ok(array) = ArrayBase::from_shape_vec(dim, data) {

src/data_traits.rs

@@ -27,6 +27,7 @@ use crate::{ArrayBase, CowRepr, Dimension, OwnedArcRepr, OwnedRepr, RawViewRepr,
 /// ***Note:*** `RawData` is not an extension interface at this point.
 /// Traits in Rust can serve many different roles. This trait is public because
 /// it is used as a bound on public methods.
+#[allow(clippy::missing_safety_doc)] // not implementable downstream
 pub unsafe trait RawData: Sized {
     /// The array element type.
     type Elem;
@@ -47,6 +48,7 @@ pub unsafe trait RawData: Sized {
 /// For an array with writable elements.
 ///
 /// ***Internal trait, see `RawData`.***
+#[allow(clippy::missing_safety_doc)] // not implementable downstream
 pub unsafe trait RawDataMut: RawData {
     /// If possible, ensures that the array has unique access to its data.
     ///
@@ -74,6 +76,7 @@ pub unsafe trait RawDataMut: RawData {
 /// An array representation that can be cloned.
 ///
 /// ***Internal trait, see `RawData`.***
+#[allow(clippy::missing_safety_doc)] // not implementable downstream
 pub unsafe trait RawDataClone: RawData {
     #[doc(hidden)]
     /// Unsafe because, `ptr` must point inside the current storage.
@@ -96,6 +99,7 @@ pub unsafe trait RawDataClone: RawData {
 /// For an array with elements that can be accessed with safe code.
 ///
 /// ***Internal trait, see `RawData`.***
+#[allow(clippy::missing_safety_doc)] // not implementable downstream
 pub unsafe trait Data: RawData {
     /// Converts the array to a uniquely owned array, cloning elements if necessary.
     #[doc(hidden)]
@@ -131,6 +135,7 @@ pub unsafe trait Data: RawData {
 // `RawDataMut::try_ensure_unique` implementation always panics or ensures that
 // the data is unique. You are also guaranteeing that `try_is_unique` always
 // returns `Some(_)`.
+#[allow(clippy::missing_safety_doc)] // not implementable downstream
 pub unsafe trait DataMut: Data + RawDataMut {
     /// Ensures that the array has unique access to its data.
     #[doc(hidden)]
@@ -449,6 +454,7 @@ unsafe impl<'a, A> DataMut for ViewRepr<&'a mut A> {}
 // The array storage must be initially mutable - copy on write arrays may require copying for
 // unsharing storage before mutating it. The initially allocated storage must be mutable so
 // that it can be mutated directly - through .raw_view_mut_unchecked() - for initialization.
+#[allow(clippy::missing_safety_doc)] // not implementable downstream
 pub unsafe trait DataOwned: Data {
     /// Corresponding owned data with MaybeUninit elements
     type MaybeUninit: DataOwned<Elem = MaybeUninit<Self::Elem>>
@@ -467,6 +473,7 @@ pub unsafe trait DataOwned: Data {
 /// A representation that is a lightweight view.
 ///
 /// ***Internal trait, see `Data`.***
+#[allow(clippy::missing_safety_doc)] // not implementable downstream
 pub unsafe trait DataShared: Clone + Data + RawDataClone {}
 
 unsafe impl<A> DataShared for OwnedArcRepr<A> {}

src/dimension/ndindex.rs

@@ -18,6 +18,7 @@ use crate::{
 /// a[[1, 1]] += 1;
 /// assert_eq!(a[(1, 1)], 4);
 /// ```
+#[allow(clippy::missing_safety_doc)] // TODO: Add doc
 pub unsafe trait NdIndex<E>: Debug {
     #[doc(hidden)]
     fn index_checked(&self, dim: &E, strides: &E) -> Option<isize>;

src/doc/ndarray_for_numpy_users/coord_transform.rs

@@ -51,40 +51,38 @@
 //! ```
 //! use ndarray::prelude::*;
 //!
-//! fn main() {
-//!     let nelems = 4;
-//!     let bunge = Array::ones((3, nelems));
-//!
-//!     let s1 = bunge.slice(s![0, ..]).mapv(f64::sin);
-//!     let c1 = bunge.slice(s![0, ..]).mapv(f64::cos);
-//!     let s2 = bunge.slice(s![1, ..]).mapv(f64::sin);
-//!     let c2 = bunge.slice(s![1, ..]).mapv(f64::cos);
-//!     let s3 = bunge.slice(s![2, ..]).mapv(f64::sin);
-//!     let c3 = bunge.slice(s![2, ..]).mapv(f64::cos);
-//!
-//!     let mut rmat = Array::zeros((3, 3, nelems).f());
-//!     for i in 0..nelems {
-//!         rmat[[0, 0, i]] = c1[i] * c3[i] - s1[i] * s3[i] * c2[i];
-//!         rmat[[0, 1, i]] = -c1[i] * s3[i] - s1[i] * c2[i] * c3[i];
-//!         rmat[[0, 2, i]] = s1[i] * s2[i];
-//!
-//!         rmat[[1, 0, i]] = s1[i] * c3[i] + c1[i] * c2[i] * s3[i];
-//!         rmat[[1, 1, i]] = -s1[i] * s3[i] + c1[i] * c2[i] * c3[i];
-//!         rmat[[1, 2, i]] = -c1[i] * s2[i];
-//!
-//!         rmat[[2, 0, i]] = s2[i] * s3[i];
-//!         rmat[[2, 1, i]] = s2[i] * c3[i];
-//!         rmat[[2, 2, i]] = c2[i];
-//!     }
-//!
-//!     let eye2d = Array::eye(3);
-//!
-//!     let mut rotated = Array::zeros((3, 3, nelems).f());
-//!     for i in 0..nelems {
-//!         rotated
-//!             .slice_mut(s![.., .., i])
-//!             .assign(&rmat.slice(s![.., .., i]).dot(&eye2d));
-//!     }
+//! let nelems = 4;
+//! let bunge = Array::ones((3, nelems));
+//!
+//! let s1 = bunge.slice(s![0, ..]).mapv(f64::sin);
+//! let c1 = bunge.slice(s![0, ..]).mapv(f64::cos);
+//! let s2 = bunge.slice(s![1, ..]).mapv(f64::sin);
+//! let c2 = bunge.slice(s![1, ..]).mapv(f64::cos);
+//! let s3 = bunge.slice(s![2, ..]).mapv(f64::sin);
+//! let c3 = bunge.slice(s![2, ..]).mapv(f64::cos);
+//!
+//! let mut rmat = Array::zeros((3, 3, nelems).f());
+//! for i in 0..nelems {
+//!     rmat[[0, 0, i]] = c1[i] * c3[i] - s1[i] * s3[i] * c2[i];
+//!     rmat[[0, 1, i]] = -c1[i] * s3[i] - s1[i] * c2[i] * c3[i];
+//!     rmat[[0, 2, i]] = s1[i] * s2[i];
+//!
+//!     rmat[[1, 0, i]] = s1[i] * c3[i] + c1[i] * c2[i] * s3[i];
+//!     rmat[[1, 1, i]] = -s1[i] * s3[i] + c1[i] * c2[i] * c3[i];
+//!     rmat[[1, 2, i]] = -c1[i] * s2[i];
+//!
+//!     rmat[[2, 0, i]] = s2[i] * s3[i];
+//!     rmat[[2, 1, i]] = s2[i] * c3[i];
+//!     rmat[[2, 2, i]] = c2[i];
+//! }
+//!
+//! let eye2d = Array::eye(3);
+//!
+//! let mut rotated = Array::zeros((3, 3, nelems).f());
+//! for i in 0..nelems {
+//!     rotated
+//!         .slice_mut(s![.., .., i])
+//!         .assign(&rmat.slice(s![.., .., i]).dot(&eye2d));
 //! }
 //! ```
 //!
@@ -96,37 +94,35 @@
 //! ```
 //! use ndarray::prelude::*;
 //!
-//! fn main() {
-//!     let nelems = 4;
-//!     let bunge = Array2::<f64>::ones((3, nelems));
-//!
-//!     let mut rmat = Array::zeros((3, 3, nelems).f());
-//!     azip!((mut rmat in rmat.axis_iter_mut(Axis(2)), bunge in bunge.axis_iter(Axis(1))) {
-//!         let s1 = bunge[0].sin();
-//!         let c1 = bunge[0].cos();
-//!         let s2 = bunge[1].sin();
-//!         let c2 = bunge[1].cos();
-//!         let s3 = bunge[2].sin();
-//!         let c3 = bunge[2].cos();
-//!
-//!         rmat[[0, 0]] = c1 * c3 - s1 * s3 * c2;
-//!         rmat[[0, 1]] = -c1 * s3 - s1 * c2 * c3;
-//!         rmat[[0, 2]] = s1 * s2;
-//!
-//!         rmat[[1, 0]] = s1 * c3 + c1 * c2 * s3;
-//!         rmat[[1, 1]] = -s1 * s3 + c1 * c2 * c3;
-//!         rmat[[1, 2]] = -c1 * s2;
-//!
-//!         rmat[[2, 0]] = s2 * s3;
-//!         rmat[[2, 1]] = s2 * c3;
-//!         rmat[[2, 2]] = c2;
-//!     });
-//!
-//!     let eye2d = Array2::<f64>::eye(3);
-//!
-//!     let mut rotated = Array3::<f64>::zeros((3, 3, nelems).f());
-//!     azip!((mut rotated in rotated.axis_iter_mut(Axis(2)), rmat in rmat.axis_iter(Axis(2))) {
-//!         rotated.assign(&rmat.dot(&eye2d));
-//!     });
-//! }
+//! let nelems = 4;
+//! let bunge = Array2::<f64>::ones((3, nelems));
+//!
+//! let mut rmat = Array::zeros((3, 3, nelems).f());
+//! azip!((mut rmat in rmat.axis_iter_mut(Axis(2)), bunge in bunge.axis_iter(Axis(1))) {
+//!     let s1 = bunge[0].sin();
+//!     let c1 = bunge[0].cos();
+//!     let s2 = bunge[1].sin();
+//!     let c2 = bunge[1].cos();
+//!     let s3 = bunge[2].sin();
+//!     let c3 = bunge[2].cos();
+//!
+//!     rmat[[0, 0]] = c1 * c3 - s1 * s3 * c2;
+//!     rmat[[0, 1]] = -c1 * s3 - s1 * c2 * c3;
+//!     rmat[[0, 2]] = s1 * s2;
+//!
+//!     rmat[[1, 0]] = s1 * c3 + c1 * c2 * s3;
+//!     rmat[[1, 1]] = -s1 * s3 + c1 * c2 * c3;
+//!     rmat[[1, 2]] = -c1 * s2;
+//!
+//!     rmat[[2, 0]] = s2 * s3;
+//!     rmat[[2, 1]] = s2 * c3;
+//!     rmat[[2, 2]] = c2;
+//! });
+//!
+//! let eye2d = Array2::<f64>::eye(3);
+//!
+//! let mut rotated = Array3::<f64>::zeros((3, 3, nelems).f());
+//! azip!((mut rotated in rotated.axis_iter_mut(Axis(2)), rmat in rmat.axis_iter(Axis(2))) {
+//!     rotated.assign(&rmat.dot(&eye2d));
+//! });
 //! ```

src/free_functions.rs

@@ -169,6 +169,7 @@ pub fn aview_mut2<A, V: FixedInitializer<Elem = A>>(xs: &mut [V]) -> ArrayViewMu
 }
 
 /// Fixed-size array used for array initialization
+#[allow(clippy::missing_safety_doc)] // Should not be implemented downstream and to be deprecated.
 pub unsafe trait FixedInitializer {
     type Elem;
     fn as_init_slice(&self) -> &[Self::Elem];

src/iterators/mod.rs

@@ -1445,6 +1445,7 @@ send_sync_read_write!(ElementsBaseMut);
 ///
 /// The iterator must produce exactly the number of elements it reported or
 /// diverge before reaching the end.
+#[allow(clippy::missing_safety_doc)] // not nameable downstream
 pub unsafe trait TrustedIterator {}
 
 use crate::indexes::IndicesIterF;

src/parallel/mod.rs

@@ -46,16 +46,14 @@
 //! use ndarray::Array2;
 //! use ndarray::parallel::prelude::*;
 //!
-//! fn main() {
-//!     let mut a = Array2::<f64>::zeros((128, 128));
+//! let mut a = Array2::<f64>::zeros((128, 128));
 //!
-//!     // Parallel versions of regular array methods
-//!     a.par_map_inplace(|x| *x = x.exp());
-//!     a.par_mapv_inplace(f64::exp);
+//! // Parallel versions of regular array methods
+//! a.par_map_inplace(|x| *x = x.exp());
+//! a.par_mapv_inplace(f64::exp);
 //!
-//!     // You can also use the parallel iterator directly
-//!     a.par_iter_mut().for_each(|x| *x = x.exp());
-//! }
+//! // You can also use the parallel iterator directly
+//! a.par_iter_mut().for_each(|x| *x = x.exp());
 //! ```
 //!
 //! ## Axis iterators
@@ -67,16 +65,14 @@
 //! use ndarray::Axis;
 //! use ndarray::parallel::prelude::*;
 //!
-//! fn main() {
-//!     let a = Array::linspace(0., 63., 64).into_shape((4, 16)).unwrap();
-//!     let mut sums = Vec::new();
-//!     a.axis_iter(Axis(0))
-//!      .into_par_iter()
-//!      .map(|row| row.sum())
-//!      .collect_into_vec(&mut sums);
+//! let a = Array::linspace(0., 63., 64).into_shape((4, 16)).unwrap();
+//! let mut sums = Vec::new();
+//! a.axis_iter(Axis(0))
+//!  .into_par_iter()
+//!  .map(|row| row.sum())
+//!  .collect_into_vec(&mut sums);
 //!
-//!     assert_eq!(sums, [120., 376., 632., 888.]);
-//! }
+//! assert_eq!(sums, [120., 376., 632., 888.]);
 //! ```
 //!
 //! ## Axis chunks iterators
@@ -88,16 +84,14 @@
 //! use ndarray::Axis;
 //! use ndarray::parallel::prelude::*;
 //!
-//! fn main() {
-//!     let a = Array::linspace(0., 63., 64).into_shape((4, 16)).unwrap();
-//!     let mut shapes = Vec::new();
-//!     a.axis_chunks_iter(Axis(0), 3)
-//!      .into_par_iter()
-//!      .map(|chunk| chunk.shape().to_owned())
-//!      .collect_into_vec(&mut shapes);
+//! let a = Array::linspace(0., 63., 64).into_shape((4, 16)).unwrap();
+//! let mut shapes = Vec::new();
+//! a.axis_chunks_iter(Axis(0), 3)
+//!  .into_par_iter()
+//!  .map(|chunk| chunk.shape().to_owned())
+//!  .collect_into_vec(&mut shapes);
 //!
-//!     assert_eq!(shapes, [vec![3, 16], vec![1, 16]]);
-//! }
+//! assert_eq!(shapes, [vec![3, 16], vec![1, 16]]);
 //! ```
 //!
 //! ## Zip
@@ -110,19 +104,17 @@
 //!
 //! type Array3f64 = Array3<f64>;
 //!
-//! fn main() {
-//!     const N: usize = 128;
-//!     let a = Array3f64::from_elem((N, N, N), 1.);
-//!     let b = Array3f64::from_elem(a.dim(), 2.);
-//!     let mut c = Array3f64::zeros(a.dim());
-//!
-//!     Zip::from(&mut c)
-//!         .and(&a)
-//!         .and(&b)
-//!         .par_for_each(|c, &a, &b| {
-//!             *c += a - b;
-//!         });
-//! }
+//! const N: usize = 128;
+//! let a = Array3f64::from_elem((N, N, N), 1.);
+//! let b = Array3f64::from_elem(a.dim(), 2.);
+//! let mut c = Array3f64::zeros(a.dim());
+//!
+//! Zip::from(&mut c)
+//!     .and(&a)
+//!     .and(&b)
+//!     .par_for_each(|c, &a, &b| {
+//!         *c += a - b;
+//!     });
 //! ```
 
 #[allow(unused_imports)] // used by rustdoc links

src/parallel/zipmacro.rs

@@ -39,18 +39,16 @@
 ///
 /// type M = Array2<f32>;
 ///
-/// fn main() {
-///     let mut a = M::zeros((16, 16));
-///     let b = M::from_elem(a.dim(), 1.);
-///     let c = M::from_elem(a.dim(), 2.);
+/// let mut a = M::zeros((16, 16));
+/// let b = M::from_elem(a.dim(), 1.);
+/// let c = M::from_elem(a.dim(), 2.);
 ///
-///     // Compute a simple ternary operation:
-///     // elementwise addition of b and c, stored in a
+/// // Compute a simple ternary operation:
+/// // elementwise addition of b and c, stored in a
 ///
-///     par_azip!((a in &mut a, &b in &b, &c in &c) *a = b + c);
+/// par_azip!((a in &mut a, &b in &b, &c in &c) *a = b + c);
 ///
-///     assert_eq!(a, &b + &c);
-/// }
+/// assert_eq!(a, &b + &c);
 /// ```
 macro_rules! par_azip {
     ($($t:tt)*) => {

src/partial.rs

@@ -38,7 +38,7 @@ impl<T> Partial<T> {
 
     #[cfg(feature = "rayon")]
     pub(crate) fn stub() -> Self {
-        Self { len: 0, ptr: 0 as *mut _ }
+        Self { len: 0, ptr: ptr::null_mut() }
     }
 
     #[cfg(feature = "rayon")]

src/slice.rs

@@ -295,6 +295,7 @@ impl From<NewAxis> for SliceInfoElem {
 /// that `D`, `Self::OutDim`, `self.in_dim()`, and `self.out_ndim()` are
 /// consistent with the `&[SliceInfoElem]` returned by `self.as_ref()` and that
 /// `self.as_ref()` always returns the same value when called multiple times.
+#[allow(clippy::missing_safety_doc)] // not implementable downstream
 pub unsafe trait SliceArg<D: Dimension>: AsRef<[SliceInfoElem]> {
     /// Dimensionality of the output array.
     type OutDim: Dimension;