Revert "No need for expr_2021"

This reverts commit 8944edc.

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;

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/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] {

src/dimension/ops.rs

@@ -8,20 +8,20 @@ pub trait DimAdd<D: Dimension>
 }
 
 macro_rules! impl_dimadd_const_out_const {
-    ($lhs:expr, $rhs:expr) => {
+    ($lhs:expr_2021, $rhs:expr_2021) => {
         impl DimAdd<Dim<[usize; $rhs]>> for Dim<[usize; $lhs]> {
             type Output = Dim<[usize; $lhs + $rhs]>;
         }
     };
 }
 
 macro_rules! impl_dimadd_const_out_dyn {
-    ($lhs:expr, IxDyn) => {
+    ($lhs:expr_2021, IxDyn) => {
         impl DimAdd<IxDyn> for Dim<[usize; $lhs]> {
             type Output = IxDyn;
         }
     };
-    ($lhs:expr, $rhs:expr) => {
+    ($lhs:expr_2021, $rhs:expr_2021) => {
         impl DimAdd<Dim<[usize; $rhs]>> for Dim<[usize; $lhs]> {
             type Output = IxDyn;
         }

src/dimension/remove_axis.rs

@@ -43,7 +43,7 @@ impl RemoveAxis for Dim<[Ix; 2]>
 }
 
 macro_rules! impl_remove_axis_array(
-    ($($n:expr),*) => (
+    ($($n:expr_2021),*) => (
     $(
         impl RemoveAxis for Dim<[Ix; $n]>
         {

src/dimension/reshape.rs

@@ -151,13 +151,13 @@ fn test_reshape()
     use crate::Dim;
 
     macro_rules! test_reshape {
-        (fail $order:ident from $from:expr, $stride:expr, to $to:expr) => {
+        (fail $order:ident from $from:expr_2021, $stride:expr_2021, to $to:expr_2021) => {
             let res = reshape_dim(&Dim($from), &Dim($stride), &Dim($to), Order::$order);
             println!("Reshape {:?} {:?} to {:?}, order {:?}\n  => {:?}",
                      $from, $stride, $to, Order::$order, res);
             let _res = res.expect_err("Expected failed reshape");
         };
-        (ok $order:ident from $from:expr, $stride:expr, to $to:expr, $to_stride:expr) => {{
+        (ok $order:ident from $from:expr_2021, $stride:expr_2021, to $to:expr_2021, $to_stride:expr_2021) => {{
             let res = reshape_dim(&Dim($from), &Dim($stride), &Dim($to), Order::$order);
             println!("Reshape {:?} {:?} to {:?}, order {:?}\n  => {:?}",
                      $from, $stride, $to, Order::$order, res);