Initial output of cargo fix --edition to 2024

Author: akern40

benches/bench1.rs

@@ -795,7 +795,7 @@ fn bench_col_iter(bench: &mut test::Bencher)
 }
 
 macro_rules! mat_mul {
-    ($modname:ident, $ty:ident, $(($name:ident, $m:expr, $n:expr, $k:expr))+) => {
+    ($modname:ident, $ty:ident, $(($name:ident, $m:expr_2021, $n:expr_2021, $k:expr_2021))+) => {
         mod $modname {
             use test::{black_box, Bencher};
             use ndarray::Array;

examples/bounds_check_elim.rs

@@ -34,7 +34,7 @@ pub fn testvec_as_slice(a: &Vec<f64>) -> f64 {
 }
 */
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn test1d_single(a: &Array1<f64>, i: usize) -> f64
 {
     if i < a.len() {
@@ -44,7 +44,7 @@ pub fn test1d_single(a: &Array1<f64>, i: usize) -> f64
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn test1d_single_mut(a: &mut Array1<f64>, i: usize) -> f64
 {
     if i < a.len() {
@@ -54,7 +54,7 @@ pub fn test1d_single_mut(a: &mut Array1<f64>, i: usize) -> f64
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn test1d_len_of(a: &Array1<f64>) -> f64
 {
     let a = a;
@@ -65,7 +65,7 @@ pub fn test1d_len_of(a: &Array1<f64>) -> f64
     sum
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn test1d_range(a: &Array1<f64>) -> f64
 {
     let mut sum = 0.;
@@ -75,7 +75,7 @@ pub fn test1d_range(a: &Array1<f64>) -> f64
     sum
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn test1d_while(a: &Array1<f64>) -> f64
 {
     let mut sum = 0.;
@@ -87,7 +87,7 @@ pub fn test1d_while(a: &Array1<f64>) -> f64
     sum
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn test2d_ranges(a: &Array2<f64>) -> f64
 {
     let mut sum = 0.;
@@ -99,7 +99,7 @@ pub fn test2d_ranges(a: &Array2<f64>) -> f64
     sum
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub fn test2d_whiles(a: &Array2<f64>) -> f64
 {
     let mut sum = 0.;

src/array_approx.rs

@@ -29,7 +29,7 @@ mod approx_methods
 }
 
 macro_rules! impl_approx_traits {
-    ($approx:ident, $doc:expr) => {
+    ($approx:ident, $doc:expr_2021) => {
         mod $approx {
             use crate::imp_prelude::*;
             use crate::Zip;

src/array_serde.rs

@@ -237,10 +237,9 @@ where
             }
         };
 
-        if let Ok(array) = ArrayBase::from_shape_vec(dim, data) {
-            Ok(array)
-        } else {
-            Err(de::Error::custom("data and dimension must match in size"))
+        match ArrayBase::from_shape_vec(dim, data) {
+            Ok(array) => Ok(array),
+            _ => Err(de::Error::custom("data and dimension must match in size")),
         }
     }
 
@@ -282,10 +281,6 @@ where
             None => return Err(de::Error::missing_field("dim")),
         };
 
-        if let Ok(array) = ArrayBase::from_shape_vec(dim, data) {
-            Ok(array)
-        } else {
-            Err(de::Error::custom("data and dimension must match in size"))
-        }
+        ArrayBase::from_shape_vec(dim, data).map_err(|_| de::Error::custom("data and dimension must match in size"))
     }
 }

src/data_traits.rs

@@ -89,11 +89,11 @@ pub unsafe trait RawDataClone: RawData
 
     #[doc(hidden)]
     unsafe fn clone_from_with_ptr(&mut self, other: &Self, ptr: NonNull<Self::Elem>) -> NonNull<Self::Elem>
-    {
+    { unsafe {
         let (data, ptr) = other.clone_with_ptr(ptr);
         *self = data;
         ptr
-    }
+    }}
 }
 
 /// Array representation trait.
@@ -388,26 +388,26 @@ unsafe impl<A> RawDataClone for OwnedRepr<A>
 where A: Clone
 {
     unsafe fn clone_with_ptr(&self, ptr: NonNull<Self::Elem>) -> (Self, NonNull<Self::Elem>)
-    {
+    { unsafe {
         let mut u = self.clone();
         let mut new_ptr = u.as_nonnull_mut();
         if size_of::<A>() != 0 {
             let our_off = (ptr.as_ptr() as isize - self.as_ptr() as isize) / mem::size_of::<A>() as isize;
             new_ptr = new_ptr.offset(our_off);
         }
         (u, new_ptr)
-    }
+    }}
 
     unsafe fn clone_from_with_ptr(&mut self, other: &Self, ptr: NonNull<Self::Elem>) -> NonNull<Self::Elem>
-    {
+    { unsafe {
         let our_off = if size_of::<A>() != 0 {
             (ptr.as_ptr() as isize - other.as_ptr() as isize) / mem::size_of::<A>() as isize
         } else {
             0
         };
         self.clone_from(other);
         self.as_nonnull_mut().offset(our_off)
-    }
+    }}
 }
 
 unsafe impl<A> RawData for ViewRepr<&A>
@@ -622,7 +622,7 @@ unsafe impl<A> RawDataClone for CowRepr<'_, A>
 where A: Clone
 {
     unsafe fn clone_with_ptr(&self, ptr: NonNull<Self::Elem>) -> (Self, NonNull<Self::Elem>)
-    {
+    { unsafe {
         match self {
             CowRepr::View(view) => {
                 let (new_view, ptr) = view.clone_with_ptr(ptr);
@@ -633,10 +633,10 @@ where A: Clone
                 (CowRepr::Owned(new_data), ptr)
             }
         }
-    }
+    }}
 
     unsafe fn clone_from_with_ptr(&mut self, other: &Self, ptr: NonNull<Self::Elem>) -> NonNull<Self::Elem>
-    {
+    { unsafe {
         match (&mut *self, other) {
             (CowRepr::View(self_), CowRepr::View(other)) => self_.clone_from_with_ptr(other, ptr),
             (CowRepr::Owned(self_), CowRepr::Owned(other)) => self_.clone_from_with_ptr(other, ptr),
@@ -651,7 +651,7 @@ where A: Clone
                 ptr
             }
         }
-    }
+    }}
 }
 
 unsafe impl<'a, A> Data for CowRepr<'a, A>
@@ -731,19 +731,19 @@ impl<A, B> RawDataSubst<B> for OwnedRepr<A>
     type Output = OwnedRepr<B>;
 
     unsafe fn data_subst(self) -> Self::Output
-    {
+    { unsafe {
         self.data_subst()
-    }
+    }}
 }
 
 impl<A, B> RawDataSubst<B> for OwnedArcRepr<A>
 {
     type Output = OwnedArcRepr<B>;
 
     unsafe fn data_subst(self) -> Self::Output
-    {
+    { unsafe {
         OwnedArcRepr(Arc::from_raw(Arc::into_raw(self.0) as *const OwnedRepr<B>))
-    }
+    }}
 }
 
 impl<A, B> RawDataSubst<B> for RawViewRepr<*const A>
@@ -791,10 +791,10 @@ impl<'a, A: 'a, B: 'a> RawDataSubst<B> for CowRepr<'a, A>
     type Output = CowRepr<'a, B>;
 
     unsafe fn data_subst(self) -> Self::Output
-    {
+    { unsafe {
         match self {
             CowRepr::View(view) => CowRepr::View(view.data_subst()),
             CowRepr::Owned(owned) => CowRepr::Owned(owned.data_subst()),
         }
-    }
+    }}
 }

src/dimension/conversion.rs

@@ -106,13 +106,13 @@ macro_rules! tuple_type {
 }
 
 macro_rules! tuple_expr {
-    ([$self_:expr] $($index:tt)*) => (
+    ([$self_:expr_2021] $($index:tt)*) => (
         ( $($self_[$index], )* )
     );
 }
 
 macro_rules! array_expr {
-    ([$self_:expr] $($index:tt)*) => (
+    ([$self_:expr_2021] $($index:tt)*) => (
         [$($self_ . $index, )*]
     );
 }

src/dimension/dim.rs

@@ -169,17 +169,17 @@ macro_rules! impl_scalar_op {
 }
 
 macro_rules! add {
-    ($x:expr, $y:expr) => {
+    ($x:expr_2021, $y:expr_2021) => {
         $x += $y;
     };
 }
 macro_rules! sub {
-    ($x:expr, $y:expr) => {
+    ($x:expr_2021, $y:expr_2021) => {
         $x -= $y;
     };
 }
 macro_rules! mul {
-    ($x:expr, $y:expr) => {
+    ($x:expr_2021, $y:expr_2021) => {
         $x *= $y;
     };
 }

src/dimension/dimension_trait.rs

@@ -402,7 +402,7 @@ pub trait Dimension:
 // Dimension impls
 
 macro_rules! impl_insert_axis_array(
-    ($n:expr) => (
+    ($n:expr_2021) => (
         #[inline]
         fn insert_axis(&self, axis: Axis) -> Self::Larger {
             debug_assert!(axis.index() <= $n);
@@ -878,7 +878,7 @@ impl Dimension for Dim<[Ix; 3]>
         let mut stride = *self;
         let mut order = Ix3(0, 1, 2);
         macro_rules! swap {
-            ($stride:expr, $order:expr, $x:expr, $y:expr) => {
+            ($stride:expr_2021, $order:expr_2021, $x:expr_2021, $y:expr_2021) => {
                 if ($stride[$x] as isize).abs() > ($stride[$y] as isize).abs() {
                     $stride.swap($x, $y);
                     $order.ixm().swap($x, $y);
@@ -904,7 +904,7 @@ impl Dimension for Dim<[Ix; 3]>
 }
 
 macro_rules! large_dim {
-    ($n:expr, $name:ident, $pattern:ty, $larger:ty, { $($insert_axis:tt)* }) => (
+    ($n:expr_2021, $name:ident, $pattern:ty, $larger:ty, { $($insert_axis:tt)* }) => (
         impl Dimension for Dim<[Ix; $n]> {
             const NDIM: Option<usize> = Some($n);
             type Pattern = $pattern;

src/dimension/macros.rs

@@ -1,12 +1,12 @@
 /// Indexing macro for Dim<[usize; N]> this
 /// gets the index at `$i` in the underlying array
 macro_rules! get {
-    ($dim:expr, $i:expr) => {
+    ($dim:expr_2021, $i:expr_2021) => {
         (*$dim.ix())[$i]
     };
 }
 macro_rules! getm {
-    ($dim:expr, $i:expr) => {
+    ($dim:expr_2021, $i:expr_2021) => {
         (*$dim.ixm())[$i]
     };
 }

src/dimension/ndindex.rs

@@ -160,7 +160,7 @@ unsafe impl NdIndex<IxDyn> for Ix
 }
 
 macro_rules! ndindex_with_array {
-    ($([$n:expr, $ix_n:ident $($index:tt)*])+) => {
+    ($([$n:expr_2021, $ix_n:ident $($index:tt)*])+) => {
         $(
         // implement NdIndex<Ix2> for [Ix; 2] and so on
         unsafe impl NdIndex<$ix_n> for [Ix; $n] {