Clippy warnings (#1)

* clean pedantic warnings

Author: gkorland

src/array.rs

@@ -22,7 +22,7 @@ struct Header {
 impl Header {
     fn as_ptr(&self) -> *const IValue {
         // Safety: pointers to the end of structs are allowed
-        unsafe { (self as *const Header).add(1) as *const IValue }
+        unsafe { (self as *const Header).add(1).cast::<IValue>() }
     }
     fn as_slice(&self) -> &[IValue] {
         // Safety: Header `len` must be accurate
@@ -88,7 +88,7 @@ impl Iterator for IntoIter {
                     .read();
                 self.index += 1;
                 if self.index >= len {
-                    IArray::dealloc(self.header as *mut u8);
+                    IArray::dealloc(self.header.cast::<u8>());
                     self.header = std::ptr::null_mut();
                 }
                 Some(res)
@@ -143,19 +143,19 @@ impl IArray {
 
     fn alloc(cap: usize) -> *mut u8 {
         unsafe {
-            let ptr = alloc(Self::layout(cap).unwrap()) as *mut Header;
+            let ptr = alloc(Self::layout(cap).unwrap()).cast::<Header>();
             (*ptr).len = 0;
             (*ptr).cap = cap;
-            ptr as *mut u8
+            ptr.cast::<u8>()
         }
     }
 
     fn realloc(ptr: *mut u8, new_cap: usize) -> *mut u8 {
         unsafe {
             let old_layout = Self::layout((*(ptr as *const Header)).cap).unwrap();
             let new_layout = Self::layout(new_cap).unwrap();
-            let ptr = realloc(ptr as *mut u8, old_layout, new_layout.size());
-            (*(ptr as *mut Header)).cap = new_cap;
+            let ptr = realloc(ptr.cast::<u8>(), old_layout, new_layout.size());
+            (*(ptr.cast::<Header>())).cap = new_cap;
             ptr
         }
     }
@@ -168,12 +168,14 @@ impl IArray {
     }
 
     /// Constructs a new empty `IArray`. Does not allocate.
+    #[must_use]
     pub fn new() -> Self {
         unsafe { IArray(IValue::new_ref(&EMPTY_HEADER, TypeTag::ArrayOrFalse)) }
     }
 
     /// Constructs a new `IArray` with the specified capacity. At least that many items
     /// can be added to the array without reallocating.
+    #[must_use]
     pub fn with_capacity(cap: usize) -> Self {
         if cap == 0 {
             Self::new()
@@ -188,29 +190,33 @@ impl IArray {
 
     // Safety: must not be static
     unsafe fn header_mut(&mut self) -> &mut Header {
-        &mut *(self.0.ptr() as *mut Header)
+        &mut *(self.0.ptr().cast::<Header>())
     }
 
     fn is_static(&self) -> bool {
         self.capacity() == 0
     }
     /// Returns the capacity of the array. This is the maximum number of items the array
     /// can hold without reallocating.
+    #[must_use]
     pub fn capacity(&self) -> usize {
         self.header().cap
     }
 
     /// Returns the number of items currently stored in the array.
+    #[must_use]
     pub fn len(&self) -> usize {
         self.header().len
     }
 
     /// Returns `true` if the array is empty.
+    #[must_use]
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
     /// Borrows a slice of [`IValue`]s from the array
+    #[must_use]
     pub fn as_slice(&self) -> &[IValue] {
         self.header().as_slice()
     }

src/de.rs

@@ -773,7 +773,7 @@ impl<'de> VariantAccess<'de> for VariantDeserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.value.map(|v| v.destructure_ref()) {
+        match self.value.map(IValue::destructure_ref) {
             Some(DestructuredRef::Array(v)) => v.deserialize_any(visitor),
             Some(other) => Err(SError::invalid_type(other.unexpected(), &"tuple variant")),
             None => Err(SError::invalid_type(
@@ -791,7 +791,7 @@ impl<'de> VariantAccess<'de> for VariantDeserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        match self.value.map(|v| v.destructure_ref()) {
+        match self.value.map(IValue::destructure_ref) {
             Some(DestructuredRef::Object(v)) => v.deserialize_any(visitor),
             Some(other) => Err(SError::invalid_type(other.unexpected(), &"struct variant")),
             None => Err(SError::invalid_type(

src/number.rs

@@ -47,7 +47,7 @@ fn cmp_u64_to_f64(a: u64, b: f64) -> Ordering {
     if can_represent_as_f64(a) {
         // If we can represent as an f64, we can just cast and compare
         (a as f64).partial_cmp(&b).unwrap()
-    } else if b <= (0x20000000000000u64 as f64) {
+    } else if b <= (0x20000000000000_u64 as f64) {
         // If the floating point number is less than all non-representable
         // integers, and our integer is non-representable, then we know
         // the integer is greater.
@@ -64,7 +64,7 @@ fn cmp_u64_to_f64(a: u64, b: f64) -> Ordering {
 
 impl Header {
     fn as_i24_unchecked(&self) -> i32 {
-        ((self.static_ as i32) << 8) | (self.short as i32)
+        (i32::from(self.static_) << 8) | i32::from(self.short)
     }
     unsafe fn as_i64_unchecked(&self) -> &i64 {
         &*(self as *const _ as *const i64).add(1)
@@ -88,12 +88,12 @@ impl Header {
         // Safety: We only call methods appropriate for the type
         unsafe {
             match self.type_ {
-                NumberType::Static => Some(self.static_ as i64),
-                NumberType::I24 => Some(self.as_i24_unchecked() as i64),
+                NumberType::Static => Some(i64::from(self.static_)),
+                NumberType::I24 => Some(i64::from(self.as_i24_unchecked())),
                 NumberType::I64 => Some(*self.as_i64_unchecked()),
                 NumberType::U64 => {
                     let v = *self.as_u64_unchecked();
-                    if v <= i64::MAX as u64 {
+                    if i64::try_from(v).is_ok() {
                         Some(v as i64)
                     } else {
                         None
@@ -153,8 +153,8 @@ impl Header {
         // Safety: We only call methods appropriate for the type
         unsafe {
             match self.type_ {
-                NumberType::Static => Some(self.static_ as f64),
-                NumberType::I24 => Some(self.as_i24_unchecked() as f64),
+                NumberType::Static => Some(f64::from(self.static_)),
+                NumberType::I24 => Some(f64::from(self.as_i24_unchecked())),
                 NumberType::I64 => {
                     let v = *self.as_i64_unchecked();
                     let can_represent = if v < 0 {
@@ -184,7 +184,7 @@ impl Header {
         // Safety: We only call methods appropriate for the type
         unsafe {
             match self.type_ {
-                NumberType::Static => Some(self.static_ as f32),
+                NumberType::Static => Some(f32::from(self.static_)),
                 NumberType::I24 => Some(self.as_i24_unchecked() as f32),
                 NumberType::I64 => {
                     let v = *self.as_i64_unchecked();
@@ -210,7 +210,7 @@ impl Header {
                 NumberType::F64 => {
                     let v = *self.as_f64_unchecked();
                     let u = v as f32;
-                    if v == (u as f64) {
+                    if v == f64::from(u) {
                         Some(u)
                     } else {
                         None
@@ -228,8 +228,8 @@ impl Header {
     fn to_f64_lossy(&self) -> f64 {
         unsafe {
             match self.type_ {
-                NumberType::Static => self.static_ as f64,
-                NumberType::I24 => self.as_i24_unchecked() as f64,
+                NumberType::Static => f64::from(self.static_),
+                NumberType::I24 => f64::from(self.as_i24_unchecked()),
                 NumberType::I64 => *self.as_i64_unchecked() as f64,
                 NumberType::U64 => *self.as_u64_unchecked() as f64,
                 NumberType::F64 => *self.as_f64_unchecked(),
@@ -361,7 +361,7 @@ impl INumber {
 
     fn alloc(type_: NumberType) -> *mut Header {
         unsafe {
-            let ptr = alloc(Self::layout(type_).unwrap()) as *mut Header;
+            let ptr = alloc(Self::layout(type_).unwrap()).cast::<Header>();
             (*ptr).type_ = type_;
             (*ptr).static_ = 0;
             (*ptr).short = 0;
@@ -372,16 +372,18 @@ impl INumber {
     fn dealloc(ptr: *mut Header) {
         unsafe {
             let layout = Self::layout((*ptr).type_).unwrap();
-            dealloc(ptr as *mut u8, layout);
+            dealloc(ptr.cast::<u8>(), layout);
         }
     }
 
     /// Returns the number zero (without a decimal point). Does not allocate.
+    #[must_use]
     pub fn zero() -> Self {
         // Safety: 0 is in the static range
         unsafe { Self::new_static(0) }
     }
     /// Returns the number one (without a decimal point). Does not allocate.
+    #[must_use]
     pub fn one() -> Self {
         // Safety: 1 is in the static range
         unsafe { Self::new_static(1) }
@@ -396,7 +398,7 @@ impl INumber {
     fn new_ptr(type_: NumberType) -> Self {
         unsafe {
             INumber(IValue::new_ptr(
-                Self::alloc(type_) as *mut u8,
+                Self::alloc(type_).cast::<u8>(),
                 TypeTag::Number,
             ))
         }
@@ -415,7 +417,7 @@ impl INumber {
 
     // Value must fit in an i24
     fn new_short(value: i32) -> Self {
-        if value >= STATIC_LOWER as i32 && value < STATIC_UPPER as i32 {
+        if value >= i32::from(STATIC_LOWER) && value < i32::from(STATIC_UPPER) {
             // Safety: We checked the value is in the static range
             unsafe { Self::new_static(value as i16) }
         } else {
@@ -443,7 +445,7 @@ impl INumber {
     }
 
     fn new_u64(value: u64) -> Self {
-        if value <= i64::MAX as u64 {
+        if i64::try_from(value).is_ok() {
             Self::new_i64(value as i64)
         } else {
             let mut res = Self::new_ptr(NumberType::U64);
@@ -487,48 +489,59 @@ impl INumber {
     }
 
     /// Converts this number to an i64 if it can be represented exactly.
+    #[must_use]
     pub fn to_i64(&self) -> Option<i64> {
         self.header().to_i64()
     }
     /// Converts this number to an f64 if it can be represented exactly.
+    #[must_use]
     pub fn to_u64(&self) -> Option<u64> {
         self.header().to_u64()
     }
     /// Converts this number to an f64 if it can be represented exactly.
+    #[must_use]
     pub fn to_f64(&self) -> Option<f64> {
         self.header().to_f64()
     }
     /// Converts this number to an f32 if it can be represented exactly.
+    #[must_use]
     pub fn to_f32(&self) -> Option<f32> {
         self.header().to_f32()
     }
     /// Converts this number to an i32 if it can be represented exactly.
+    #[must_use]
     pub fn to_i32(&self) -> Option<i32> {
         self.header().to_i64().and_then(|x| x.try_into().ok())
     }
     /// Converts this number to a u32 if it can be represented exactly.
+    #[must_use]
     pub fn to_u32(&self) -> Option<u32> {
         self.header().to_u64().and_then(|x| x.try_into().ok())
     }
     /// Converts this number to an isize if it can be represented exactly.
+    #[must_use]
     pub fn to_isize(&self) -> Option<isize> {
         self.header().to_i64().and_then(|x| x.try_into().ok())
     }
     /// Converts this number to a usize if it can be represented exactly.
+    #[must_use]
     pub fn to_usize(&self) -> Option<usize> {
         self.header().to_u64().and_then(|x| x.try_into().ok())
     }
     /// Converts this number to an f64, potentially losing precision in the process.
+    #[must_use]
     pub fn to_f64_lossy(&self) -> f64 {
         self.header().to_f64_lossy()
     }
     /// Converts this number to an f32, potentially losing precision in the process.
+    #[must_use]
     pub fn to_f32_lossy(&self) -> f32 {
         self.to_f64_lossy() as f32
     }
 
     /// This allows distinguishing between `1.0` and `1` in the original JSON.
     /// Numeric operations will otherwise treat these two values as equivalent.
+    #[must_use]
     pub fn has_decimal_point(&self) -> bool {
         self.header().has_decimal_point()
     }
@@ -559,18 +572,18 @@ impl From<u64> for INumber {
 }
 impl From<u32> for INumber {
     fn from(v: u32) -> Self {
-        Self::new_u64(v as u64)
+        Self::new_u64(u64::from(v))
     }
 }
 impl From<u16> for INumber {
     fn from(v: u16) -> Self {
-        Self::new_short(v as i32)
+        Self::new_short(i32::from(v))
     }
 }
 impl From<u8> for INumber {
     fn from(v: u8) -> Self {
         // Safety: All u8s are in the static range
-        unsafe { Self::new_static(v as i16) }
+        unsafe { Self::new_static(i16::from(v)) }
     }
 }
 impl From<usize> for INumber {
@@ -586,18 +599,18 @@ impl From<i64> for INumber {
 }
 impl From<i32> for INumber {
     fn from(v: i32) -> Self {
-        Self::new_i64(v as i64)
+        Self::new_i64(i64::from(v))
     }
 }
 impl From<i16> for INumber {
     fn from(v: i16) -> Self {
-        Self::new_short(v as i32)
+        Self::new_short(i32::from(v))
     }
 }
 impl From<i8> for INumber {
     fn from(v: i8) -> Self {
         // Safety: All i8s are in the static range
-        unsafe { Self::new_static(v as i16) }
+        unsafe { Self::new_static(i16::from(v)) }
     }
 }
 impl From<isize> for INumber {
@@ -621,7 +634,7 @@ impl TryFrom<f32> for INumber {
     type Error = ();
     fn try_from(v: f32) -> Result<Self, ()> {
         if v.is_finite() {
-            Ok(Self::new_f64(v as f64))
+            Ok(Self::new_f64(f64::from(v)))
         } else {
             Err(())
         }
@@ -702,12 +715,12 @@ mod tests {
         let x: INumber = 0x1000000.into();
         assert_eq!(x.to_i64(), Some(0x1000000));
         assert_eq!(x.to_u64(), Some(0x1000000));
-        assert_eq!(x.to_f64(), Some(16777216.0));
+        assert_eq!(x.to_f64(), Some(16_777_216.0));
 
         let x: INumber = i64::MIN.into();
         assert_eq!(x.to_i64(), Some(i64::MIN));
         assert_eq!(x.to_u64(), None);
-        assert_eq!(x.to_f64(), Some(-9223372036854775808.0));
+        assert_eq!(x.to_f64(), Some(-9_223_372_036_854_775_808.0));
 
         let x: INumber = i64::MAX.into();
         assert_eq!(x.to_i64(), Some(i64::MAX));
@@ -720,9 +733,9 @@ mod tests {
         assert_eq!(x.to_f64(), None);
 
         let x: INumber = 13369629.into();
-        assert_eq!(x.to_i64(), Some(13369629));
-        assert_eq!(x.to_u64(), Some(13369629));
-        assert_eq!(x.to_f64(), Some(13369629.0));
+        assert_eq!(x.to_i64(), Some(13_369_629));
+        assert_eq!(x.to_u64(), Some(13_369_629));
+        assert_eq!(x.to_f64(), Some(13_369_629.0));
 
         let x: INumber = 0x800000.into();
         assert_eq!(x.to_i64(), Some(0x800000));
@@ -753,6 +766,6 @@ mod tests {
         assert!(INumber::try_from(1e30).unwrap() > INumber::from(i64::MAX));
         assert!(INumber::try_from(-1e30).unwrap() < INumber::from(i64::MIN));
         assert!(INumber::try_from(-1e30).unwrap() < INumber::from(i64::MIN));
-        assert!(INumber::try_from(99999999000.0).unwrap() < INumber::from(99999999001u64));
+        assert!(INumber::try_from(99_999_999_000.0).unwrap() < INumber::from(99_999_999_001_u64));
     }
 }