Update Clippy to Rust v1.79 (#3987)

Author: daxpedda

crates/backend/src/encode.rs

@@ -437,7 +437,7 @@ impl Encode for u32 {
 
 impl Encode for usize {
     fn encode(&self, dst: &mut Encoder) {
-        assert!(*self <= u32::max_value() as usize);
+        assert!(*self <= u32::MAX as usize);
         (*self as u32).encode(dst);
     }
 }

crates/webidl/src/util.rs

@@ -103,13 +103,11 @@ pub(crate) fn array(base_ty: &str, pos: TypePosition, immutable: bool) -> syn::T
 
 /// Map a webidl const value to the correct wasm-bindgen const value
 pub fn webidl_const_v_to_backend_const_v(v: &ConstValueLit) -> ConstValue {
-    use std::f64::{INFINITY, NAN, NEG_INFINITY};
-
     match *v {
         ConstValueLit::Boolean(b) => ConstValue::Boolean(b.0),
-        ConstValueLit::Float(FloatLit::NegInfinity(_)) => ConstValue::Float(NEG_INFINITY),
-        ConstValueLit::Float(FloatLit::Infinity(_)) => ConstValue::Float(INFINITY),
-        ConstValueLit::Float(FloatLit::NaN(_)) => ConstValue::Float(NAN),
+        ConstValueLit::Float(FloatLit::NegInfinity(_)) => ConstValue::Float(f64::NEG_INFINITY),
+        ConstValueLit::Float(FloatLit::Infinity(_)) => ConstValue::Float(f64::INFINITY),
+        ConstValueLit::Float(FloatLit::NaN(_)) => ConstValue::Float(f64::NAN),
         ConstValueLit::Float(FloatLit::Value(s)) => ConstValue::Float(s.0.parse().unwrap()),
         ConstValueLit::Integer(lit) => {
             let mklit = |orig_text: &str, base: u32, offset: usize| {
@@ -125,7 +123,7 @@ pub fn webidl_const_v_to_backend_const_v(v: &ConstValueLit) -> ConstValue {
                 let n = u64::from_str_radix(text, base)
                     .unwrap_or_else(|_| panic!("literal too big: {}", orig_text));
                 if negative {
-                    let n = if n > (i64::min_value() as u64).wrapping_neg() {
+                    let n = if n > (i64::MIN as u64).wrapping_neg() {
                         panic!("literal too big: {}", orig_text)
                     } else {
                         n.wrapping_neg() as i64

examples/webaudio/src/lib.rs

@@ -93,12 +93,7 @@ impl FmOsc {
     /// Sets the gain for this oscillator, between 0.0 and 1.0.
     #[wasm_bindgen]
     pub fn set_gain(&self, mut gain: f32) {
-        if gain > 1.0 {
-            gain = 1.0;
-        }
-        if gain < 0.0 {
-            gain = 0.0;
-        }
+        gain = gain.clamp(0.0, 1.0);
         self.gain.gain().set_value(gain);
     }
 

src/lib.rs

@@ -17,7 +17,6 @@ use core::ops::{
     Add, BitAnd, BitOr, BitXor, Deref, DerefMut, Div, Mul, Neg, Not, Rem, Shl, Shr, Sub,
 };
 use core::ptr::NonNull;
-use core::u32;
 
 use crate::convert::{FromWasmAbi, TryFromJsValue, WasmRet, WasmSlice};
 
@@ -1503,7 +1502,7 @@ pub mod __rt {
 
         pub fn borrow(&self) -> Ref<T> {
             unsafe {
-                if self.borrow.get() == usize::max_value() {
+                if self.borrow.get() == usize::MAX {
                     borrow_fail();
                 }
                 self.borrow.set(self.borrow.get() + 1);
@@ -1519,7 +1518,7 @@ pub mod __rt {
                 if self.borrow.get() != 0 {
                     borrow_fail();
                 }
-                self.borrow.set(usize::max_value());
+                self.borrow.set(usize::MAX);
                 RefMut {
                     value: &mut *self.value.get(),
                     borrow: &self.borrow,

tests/wasm/bigint.rs

@@ -25,22 +25,22 @@ pub fn neg_one() -> i64 {
 
 #[wasm_bindgen]
 pub fn i32_min() -> i64 {
-    i32::min_value() as i64
+    i32::MIN as i64
 }
 
 #[wasm_bindgen]
 pub fn u32_max() -> u64 {
-    u32::max_value() as u64
+    u32::MAX as u64
 }
 
 #[wasm_bindgen]
 pub fn i64_min() -> i64 {
-    i64::min_value()
+    i64::MIN
 }
 
 #[wasm_bindgen]
 pub fn u64_max() -> u64 {
-    u64::max_value()
+    u64::MAX
 }
 
 #[wasm_bindgen]
@@ -65,12 +65,12 @@ pub fn u64_jsvalue_identity(a: u64) -> JsValue {
 
 #[wasm_bindgen]
 pub fn i128_min_jsvalue() -> JsValue {
-    JsValue::from(i128::min_value())
+    JsValue::from(i128::MIN)
 }
 
 #[wasm_bindgen]
 pub fn u128_max_jsvalue() -> JsValue {
-    JsValue::from(u128::max_value())
+    JsValue::from(u128::MAX)
 }
 
 #[wasm_bindgen]

tests/wasm/math.rs

@@ -94,24 +94,24 @@ macro_rules! t_roundtrip {
 
 #[wasm_bindgen_test]
 fn limits_correct() {
-    t_roundtrip!(roundtrip_i8(i8::min_value()));
+    t_roundtrip!(roundtrip_i8(i8::MIN));
     t_roundtrip!(roundtrip_i8(0));
-    t_roundtrip!(roundtrip_i8(i8::max_value()));
-    t_roundtrip!(roundtrip_i16(i16::min_value()));
+    t_roundtrip!(roundtrip_i8(i8::MAX));
+    t_roundtrip!(roundtrip_i16(i16::MIN));
     t_roundtrip!(roundtrip_i16(0));
-    t_roundtrip!(roundtrip_i16(i16::max_value()));
-    t_roundtrip!(roundtrip_i32(i32::min_value()));
+    t_roundtrip!(roundtrip_i16(i16::MAX));
+    t_roundtrip!(roundtrip_i32(i32::MIN));
     t_roundtrip!(roundtrip_i32(0));
-    t_roundtrip!(roundtrip_i32(i32::max_value()));
-    t_roundtrip!(roundtrip_u8(u8::min_value()));
+    t_roundtrip!(roundtrip_i32(i32::MAX));
+    t_roundtrip!(roundtrip_u8(u8::MIN));
     t_roundtrip!(roundtrip_u8(0));
-    t_roundtrip!(roundtrip_u8(u8::max_value()));
-    t_roundtrip!(roundtrip_u16(u16::min_value()));
+    t_roundtrip!(roundtrip_u8(u8::MAX));
+    t_roundtrip!(roundtrip_u16(u16::MIN));
     t_roundtrip!(roundtrip_u16(0));
-    t_roundtrip!(roundtrip_u16(u16::max_value()));
-    t_roundtrip!(roundtrip_u32(u32::min_value()));
+    t_roundtrip!(roundtrip_u16(u16::MAX));
+    t_roundtrip!(roundtrip_u32(u32::MIN));
     t_roundtrip!(roundtrip_u32(0));
-    t_roundtrip!(roundtrip_u32(u32::max_value()));
+    t_roundtrip!(roundtrip_u32(u32::MAX));
 
     test_js_roundtrip();
 

tests/wasm/optional_primitives.rs

@@ -43,12 +43,12 @@ pub fn optional_i32_neg_one() -> Option<i32> {
 
 #[wasm_bindgen]
 pub fn optional_i32_min() -> Option<i32> {
-    Some(i32::min_value())
+    Some(i32::MIN)
 }
 
 #[wasm_bindgen]
 pub fn optional_i32_max() -> Option<i32> {
-    Some(i32::max_value())
+    Some(i32::MAX)
 }
 
 #[wasm_bindgen]
@@ -73,12 +73,12 @@ pub fn optional_u32_one() -> Option<u32> {
 
 #[wasm_bindgen]
 pub fn optional_u32_min() -> Option<u32> {
-    Some(u32::min_value())
+    Some(u32::MIN)
 }
 
 #[wasm_bindgen]
 pub fn optional_u32_max() -> Option<u32> {
-    Some(u32::max_value())
+    Some(u32::MAX)
 }
 
 #[wasm_bindgen]
@@ -108,12 +108,12 @@ pub fn optional_isize_neg_one() -> Option<isize> {
 
 #[wasm_bindgen]
 pub fn optional_isize_min() -> Option<isize> {
-    Some(isize::min_value())
+    Some(isize::MIN)
 }
 
 #[wasm_bindgen]
 pub fn optional_isize_max() -> Option<isize> {
-    Some(isize::max_value())
+    Some(isize::MAX)
 }
 
 #[wasm_bindgen]
@@ -138,12 +138,12 @@ pub fn optional_usize_one() -> Option<usize> {
 
 #[wasm_bindgen]
 pub fn optional_usize_min() -> Option<usize> {
-    Some(usize::min_value())
+    Some(usize::MIN)
 }
 
 #[wasm_bindgen]
 pub fn optional_usize_max() -> Option<usize> {
-    Some(usize::max_value())
+    Some(usize::MAX)
 }
 
 #[wasm_bindgen]
@@ -223,12 +223,12 @@ pub fn optional_i8_neg_one() -> Option<i8> {
 
 #[wasm_bindgen]
 pub fn optional_i8_min() -> Option<i8> {
-    Some(i8::min_value())
+    Some(i8::MIN)
 }
 
 #[wasm_bindgen]
 pub fn optional_i8_max() -> Option<i8> {
-    Some(i8::max_value())
+    Some(i8::MAX)
 }
 
 #[wasm_bindgen]
@@ -253,12 +253,12 @@ pub fn optional_u8_one() -> Option<u8> {
 
 #[wasm_bindgen]
 pub fn optional_u8_min() -> Option<u8> {
-    Some(u8::min_value())
+    Some(u8::MIN)
 }
 
 #[wasm_bindgen]
 pub fn optional_u8_max() -> Option<u8> {
-    Some(u8::max_value())
+    Some(u8::MAX)
 }
 
 #[wasm_bindgen]
@@ -288,12 +288,12 @@ pub fn optional_i16_neg_one() -> Option<i16> {
 
 #[wasm_bindgen]
 pub fn optional_i16_min() -> Option<i16> {
-    Some(i16::min_value())
+    Some(i16::MIN)
 }
 
 #[wasm_bindgen]
 pub fn optional_i16_max() -> Option<i16> {
-    Some(i16::max_value())
+    Some(i16::MAX)
 }
 
 #[wasm_bindgen]
@@ -318,12 +318,12 @@ pub fn optional_u16_one() -> Option<u16> {
 
 #[wasm_bindgen]
 pub fn optional_u16_min() -> Option<u16> {
-    Some(u16::min_value())
+    Some(u16::MIN)
 }
 
 #[wasm_bindgen]
 pub fn optional_u16_max() -> Option<u16> {
-    Some(u16::max_value())
+    Some(u16::MAX)
 }
 
 #[wasm_bindgen]
@@ -353,12 +353,12 @@ pub fn optional_i64_neg_one() -> Option<i64> {
 
 #[wasm_bindgen]
 pub fn optional_i64_min() -> Option<i64> {
-    Some(i64::min_value())
+    Some(i64::MIN)
 }
 
 #[wasm_bindgen]
 pub fn optional_i64_max() -> Option<i64> {
-    Some(i64::max_value())
+    Some(i64::MAX)
 }
 
 #[wasm_bindgen]
@@ -383,12 +383,12 @@ pub fn optional_u64_one() -> Option<u64> {
 
 #[wasm_bindgen]
 pub fn optional_u64_min() -> Option<u64> {
-    Some(u64::min_value())
+    Some(u64::MIN)
 }
 
 #[wasm_bindgen]
 pub fn optional_u64_max() -> Option<u64> {
-    Some(u64::max_value())
+    Some(u64::MAX)
 }
 
 #[wasm_bindgen]

tests/wasm/usize.rs

@@ -25,22 +25,22 @@ pub fn isize_neg_one() -> isize {
 
 #[wasm_bindgen]
 pub fn isize_i32_min() -> isize {
-    i32::min_value() as isize
+    i32::MIN as isize
 }
 
 #[wasm_bindgen]
 pub fn usize_u32_max() -> usize {
-    u32::max_value() as usize
+    u32::MAX as usize
 }
 
 #[wasm_bindgen]
 pub fn isize_min() -> isize {
-    isize::min_value()
+    isize::MIN
 }
 
 #[wasm_bindgen]
 pub fn usize_max() -> usize {
-    usize::max_value()
+    usize::MAX
 }
 
 #[wasm_bindgen]