Appease new clippy warnings with Rust 1.79.0

jmmv · jmmv · commit b77445b5bb25 · 2024-06-25T07:47:08.000-07:00
diff --git a/core/examples/dsl.rs b/core/examples/dsl.rs
@@ -79,7 +79,7 @@ impl Callable for NumLightsFunction {
     async fn exec(&self, scope: Scope<'_>, _machine: &mut Machine) -> CallResult {
         debug_assert_eq!(0, scope.nargs());
         let num = self.lights.borrow().len();
-        assert!(num <= std::i32::MAX as usize, "Ended up with too many lights");
+        assert!(num <= i32::MAX as usize, "Ended up with too many lights");
         scope.return_integer(num as i32)
     }
 }
diff --git a/core/src/value.rs b/core/src/value.rs
@@ -189,8 +189,6 @@ mod tests {
 
     #[test]
     fn test_value_maybe_cast() {
-        use std::i32;
-
         let all_types = [ExprType::Boolean, ExprType::Double, ExprType::Integer, ExprType::Text];
         for target in all_types {
             assert_eq!(Boolean(true), Boolean(true).maybe_cast(Some(target)).unwrap());
@@ -271,50 +269,47 @@ mod tests {
     #[test]
     fn test_value_add_integer() {
         assert_eq!(5, add_integer(2, 3).unwrap());
-        assert_eq!(std::i32::MAX, add_integer(std::i32::MAX, 0).unwrap());
-        assert_eq!("Integer overflow", format!("{}", add_integer(std::i32::MAX, 1).unwrap_err()));
+        assert_eq!(i32::MAX, add_integer(i32::MAX, 0).unwrap());
+        assert_eq!("Integer overflow", format!("{}", add_integer(i32::MAX, 1).unwrap_err()));
     }
 
     #[test]
     fn test_value_sub_integer() {
         assert_eq!(-1, sub_integer(2, 3).unwrap());
-        assert_eq!(std::i32::MIN, sub_integer(std::i32::MIN, 0).unwrap());
-        assert_eq!("Integer underflow", format!("{}", sub_integer(std::i32::MIN, 1).unwrap_err()));
+        assert_eq!(i32::MIN, sub_integer(i32::MIN, 0).unwrap());
+        assert_eq!("Integer underflow", format!("{}", sub_integer(i32::MIN, 1).unwrap_err()));
     }
 
     #[test]
     fn test_value_mul_integer() {
         assert_eq!(6, mul_integer(2, 3).unwrap());
-        assert_eq!(std::i32::MAX, mul_integer(std::i32::MAX, 1).unwrap());
-        assert_eq!("Integer overflow", format!("{}", mul_integer(std::i32::MAX, 2).unwrap_err()));
+        assert_eq!(i32::MAX, mul_integer(i32::MAX, 1).unwrap());
+        assert_eq!("Integer overflow", format!("{}", mul_integer(i32::MAX, 2).unwrap_err()));
     }
 
     #[test]
     fn test_value_div_integer() {
         assert_eq!(2, div_integer(10, 5).unwrap());
         assert_eq!(6, div_integer(20, 3).unwrap());
-        assert_eq!(std::i32::MIN, div_integer(std::i32::MIN, 1).unwrap());
+        assert_eq!(i32::MIN, div_integer(i32::MIN, 1).unwrap());
         assert_eq!("Division by zero", format!("{}", div_integer(4, 0).unwrap_err()));
-        assert_eq!("Integer underflow", format!("{}", div_integer(std::i32::MIN, -1).unwrap_err()));
+        assert_eq!("Integer underflow", format!("{}", div_integer(i32::MIN, -1).unwrap_err()));
     }
 
     #[test]
     fn test_value_modulo_integer() {
         assert_eq!(0, modulo_integer(10, 5).unwrap());
         assert_eq!(2, modulo_integer(20, 3).unwrap());
         assert_eq!("Modulo by zero", format!("{}", modulo_integer(4, 0).unwrap_err()));
-        assert_eq!(
-            "Integer underflow",
-            format!("{}", modulo_integer(std::i32::MIN, -1).unwrap_err())
-        );
+        assert_eq!("Integer underflow", format!("{}", modulo_integer(i32::MIN, -1).unwrap_err()));
     }
 
     #[test]
     fn test_value_pow_integer() {
         assert_eq!(1, pow_integer(0, 0).unwrap());
         assert_eq!(9, pow_integer(3, 2).unwrap());
-        assert_eq!(std::i32::MAX, pow_integer(std::i32::MAX, 1).unwrap());
-        assert_eq!("Integer overflow", format!("{}", pow_integer(std::i32::MAX, 2).unwrap_err()));
+        assert_eq!(i32::MAX, pow_integer(i32::MAX, 1).unwrap());
+        assert_eq!("Integer overflow", format!("{}", pow_integer(i32::MAX, 2).unwrap_err()));
         assert_eq!(
             "Exponent -3 cannot be negative",
             format!("{}", pow_integer(1, -3).unwrap_err())
diff --git a/repl/src/demos.rs b/repl/src/demos.rs
@@ -106,7 +106,7 @@ impl Drive for DemosDrive {
         }
         let files = self.demos.len();
 
-        let disk_quota = if bytes <= std::u64::MAX as usize && files <= std::u64::MAX as usize {
+        let disk_quota = if bytes <= u64::MAX as usize && files <= u64::MAX as usize {
             Some(DiskSpace::new(bytes as u64, files as u64))
         } else {
             // Cannot represent the amount of disk within a DiskSpace.
diff --git a/std/src/console/cmds.rs b/std/src/console/cmds.rs
@@ -155,7 +155,7 @@ impl Callable for ColorCommand {
 
     async fn exec(&self, mut scope: Scope<'_>, _machine: &mut Machine) -> CallResult {
         fn get_color((i, pos): (i32, LineCol)) -> Result<Option<u8>, CallError> {
-            if i >= 0 && i <= std::u8::MAX as i32 {
+            if i >= 0 && i <= u8::MAX as i32 {
                 Ok(Some(i as u8))
             } else {
                 Err(CallError::ArgumentError(pos, "Color out of range".to_owned()))
diff --git a/std/src/gpio/fakes.rs b/std/src/gpio/fakes.rs
@@ -111,7 +111,7 @@ impl MockOp {
             ));
         }
         let pin = datum / 100;
-        if pin > std::u8::MAX as i32 {
+        if pin > u8::MAX as i32 {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidData,
                 format!("Pin number too large at __GPIO_MOCK_DATA({})", pos),
diff --git a/std/src/gpio/mod.rs b/std/src/gpio/mod.rs
@@ -50,7 +50,7 @@ impl Pin {
                 format!("Pin number {} must be positive", i),
             ));
         }
-        if i > std::u8::MAX as i32 {
+        if i > u8::MAX as i32 {
             return Err(CallError::ArgumentError(pos, format!("Pin number {} is too large", i)));
         }
         Ok(Self(i as u8))
diff --git a/std/src/numerics.rs b/std/src/numerics.rs
@@ -90,7 +90,7 @@ impl Prng {
 
     /// Returns the previously returned random number.
     fn last(&self) -> f64 {
-        (self.last as f64) / (std::u32::MAX as f64)
+        (self.last as f64) / (u32::MAX as f64)
     }
 
     /// Computes the next random number and returns it.
diff --git a/std/src/strings.rs b/std/src/strings.rs
@@ -296,7 +296,7 @@ impl Callable for LenFunction {
         debug_assert_eq!(1, scope.nargs());
         let (s, spos) = scope.pop_string_with_pos();
 
-        if s.len() > std::i32::MAX as usize {
+        if s.len() > i32::MAX as usize {
             Err(CallError::InternalError(spos, "String too long".to_owned()))
         } else {
             scope.return_integer(s.len() as i32)
@@ -613,17 +613,17 @@ mod tests {
     #[test]
     fn test_value_parse_boolean() {
         for s in &["true", "TrUe", "TRUE", "yes", "Yes", "y", "Y"] {
-            assert!(parse_boolean(*s).unwrap());
+            assert!(parse_boolean(s).unwrap());
         }
 
         for s in &["false", "FaLsE", "FALSE", "no", "No", "n", "N"] {
-            assert!(!parse_boolean(*s).unwrap());
+            assert!(!parse_boolean(s).unwrap());
         }
 
         for s in &["ye", "0", "1", " true"] {
             assert_eq!(
                 format!("Invalid boolean literal {}", s),
-                format!("{}", parse_boolean(*s).unwrap_err())
+                format!("{}", parse_boolean(s).unwrap_err())
             );
         }
     }
diff --git a/web/src/lib.rs b/web/src/lib.rs
@@ -107,7 +107,7 @@ fn js_sleep(
     yielder: Rc<RefCell<Yielder>>,
 ) -> Pin<Box<dyn Future<Output = CallResult>>> {
     let ms = d.as_millis();
-    if ms > std::i32::MAX as u128 {
+    if ms > i32::MAX as u128 {
         // The JavaScript setTimeout function only takes i32s so ensure our value fits.  If it
         // doesn't, you can imagine chaining calls to setTimeout to achieve the desired delay...
         // but the numbers we are talking about are so big that this doesn't make sense.
@@ -389,7 +389,7 @@ mod tests {
     async fn test_js_sleep_too_big() {
         let yielder = Rc::from(RefCell::from(Yielder::new()));
         match js_sleep(
-            Duration::from_millis(std::i32::MAX as u64 + 1),
+            Duration::from_millis(i32::MAX as u64 + 1),
             LineCol { line: 1, col: 2 },
             yielder,
         )

Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ impl Callable for NumLightsFunction {`
`79`	`79`	`async fn exec(&self, scope: Scope<'_>, _machine: &mut Machine) -> CallResult {`
`80`	`80`	`debug_assert_eq!(0, scope.nargs());`
`81`	`81`	`let num = self.lights.borrow().len();`
`82`		`- assert!(num <= std::i32::MAX as usize, "Ended up with too many lights");`
	`82`	`+ assert!(num <= i32::MAX as usize, "Ended up with too many lights");`
`83`	`83`	`scope.return_integer(num as i32)`
`84`	`84`	`}`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ impl Drive for DemosDrive {`
`106`	`106`	`}`
`107`	`107`	`let files = self.demos.len();`
`108`	`108`
`109`		`- let disk_quota = if bytes <= std::u64::MAX as usize && files <= std::u64::MAX as usize {`
	`109`	`+ let disk_quota = if bytes <= u64::MAX as usize && files <= u64::MAX as usize {`
`110`	`110`	`Some(DiskSpace::new(bytes as u64, files as u64))`
`111`	`111`	`} else {`
`112`	`112`	`// Cannot represent the amount of disk within a DiskSpace.`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ impl MockOp {`
`111`	`111`	`));`
`112`	`112`	`}`
`113`	`113`	`let pin = datum / 100;`
`114`		`- if pin > std::u8::MAX as i32 {`
	`114`	`+ if pin > u8::MAX as i32 {`
`115`	`115`	`return Err(io::Error::new(`
`116`	`116`	`io::ErrorKind::InvalidData,`
`117`	`117`	`format!("Pin number too large at __GPIO_MOCK_DATA({})", pos),`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ impl Pin {`
`50`	`50`	`format!("Pin number {} must be positive", i),`
`51`	`51`	`));`
`52`	`52`	`}`
`53`		`- if i > std::u8::MAX as i32 {`
	`53`	`+ if i > u8::MAX as i32 {`
`54`	`54`	`return Err(CallError::ArgumentError(pos, format!("Pin number {} is too large", i)));`
`55`	`55`	`}`
`56`	`56`	`Ok(Self(i as u8))`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ impl Prng {`
`90`	`90`
`91`	`91`	`/// Returns the previously returned random number.`
`92`	`92`	`fn last(&self) -> f64 {`
`93`		`- (self.last as f64) / (std::u32::MAX as f64)`
	`93`	`+ (self.last as f64) / (u32::MAX as f64)`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`/// Computes the next random number and returns it.`