clippy: use type associated constants

src/arithmetic.rs

@@ -168,7 +168,7 @@ fn push_literal(interm: &mut Vec<ArithmeticTerm>, c: &Literal) -> Result<(), Ari
             Number::Float(OrderedFloat(std::f64::consts::PI)),
         )),
         Literal::Atom(name) if name == &atom!("epsilon") => interm.push(ArithmeticTerm::Number(
-            Number::Float(OrderedFloat(std::f64::EPSILON)),
+            Number::Float(OrderedFloat(f64::EPSILON)),
         )),
         _ => return Err(ArithmeticError::NonEvaluableFunctor(*c, 0)),
     }

src/machine/arithmetic_ops.rs

@@ -641,10 +641,17 @@ pub(crate) fn shr(n1: Number, n2: Number, arena: &mut Arena) -> Result<Number, M
             let n1_i = n1.get_num();
             let n2_i = n2.get_num();
 
+            // FIXME(arithmetic_overflow)
+            // what should this do for too large n2,
+            // - logical right shift should probably turn to 0
+            // - arithmetic right shift should maybe differ for negative numbers
+            //
+            // note: negaitve n2 is already handled above
+            #[allow(arithmetic_overflow)]
             if let Ok(n2) = usize::try_from(n2_i) {
                 Ok(Number::arena_from(n1_i >> n2, arena))
             } else {
-                Ok(Number::arena_from(n1_i >> usize::max_value(), arena))
+                Ok(Number::arena_from(n1_i >> usize::MAX, arena))
             }
         }
         (Number::Fixnum(n1), Number::Integer(n2)) => {
@@ -654,25 +661,19 @@ pub(crate) fn shr(n1: Number, n2: Number, arena: &mut Arena) -> Result<Number, M
 
             match result {
                 Ok(n2) => Ok(Number::arena_from(n1 >> n2, arena)),
-                Err(_) => Ok(Number::arena_from(n1 >> usize::max_value(), arena)),
+                Err(_) => Ok(Number::arena_from(n1 >> usize::MAX, arena)),
             }
         }
         (Number::Integer(n1), Number::Fixnum(n2)) => match usize::try_from(n2.get_num()) {
             Ok(n2) => Ok(Number::arena_from(Integer::from(&*n1 >> n2), arena)),
-            _ => Ok(Number::arena_from(
+            _ => Ok(Number::arena_from(Integer::from(&*n1 >> usize::MAX), arena)),
-                Integer::from(&*n1 >> usize::max_value()),
-                arena,
-            )),
         },
         (Number::Integer(n1), Number::Integer(n2)) => {
             let result: Result<usize, _> = (&*n2).try_into();
 
             match result {
                 Ok(n2) => Ok(Number::arena_from(Integer::from(&*n1 >> n2), arena)),
-                Err(_) => Ok(Number::arena_from(
+                Err(_) => Ok(Number::arena_from(Integer::from(&*n1 >> usize::MAX), arena)),
-                    Integer::from(&*n1 >> usize::max_value()),
-                    arena,
-                )),
             }
         }
         (Number::Integer(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),
@@ -700,7 +701,7 @@ pub(crate) fn shl(n1: Number, n2: Number, arena: &mut Arena) -> Result<Number, M
                 Ok(Number::arena_from(n1_i << n2, arena))
             } else {
                 let n1 = Integer::from(n1_i);
-                Ok(Number::arena_from(n1 << usize::max_value(), arena))
+                Ok(Number::arena_from(n1 << usize::MAX, arena))
             }
         }
         (Number::Fixnum(n1), Number::Integer(n2)) => {
@@ -708,22 +709,16 @@ pub(crate) fn shl(n1: Number, n2: Number, arena: &mut Arena) -> Result<Number, M
 
             match (&*n2).try_into() as Result<usize, _> {
                 Ok(n2) => Ok(Number::arena_from(n1 << n2, arena)),
-                _ => Ok(Number::arena_from(n1 << usize::max_value(), arena)),
+                _ => Ok(Number::arena_from(n1 << usize::MAX, arena)),
             }
         }
         (Number::Integer(n1), Number::Fixnum(n2)) => match usize::try_from(n2.get_num()) {
             Ok(n2) => Ok(Number::arena_from(Integer::from(&*n1 << n2), arena)),
-            _ => Ok(Number::arena_from(
+            _ => Ok(Number::arena_from(Integer::from(&*n1 << usize::MAX), arena)),
-                Integer::from(&*n1 << usize::max_value()),
-                arena,
-            )),
         },
         (Number::Integer(n1), Number::Integer(n2)) => match (&*n2).try_into() as Result<usize, _> {
             Ok(n2) => Ok(Number::arena_from(Integer::from(&*n1 << n2), arena)),
-            _ => Ok(Number::arena_from(
+            _ => Ok(Number::arena_from(Integer::from(&*n1 << usize::MAX), arena)),
-                Integer::from(&*n1 << usize::max_value()),
-                arena,
-            )),
         },
         (Number::Integer(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),
         (Number::Fixnum(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),