Obey clippy

Signed-off-by: Heinz N. Gies <heinz@licenser.net>

Author: Licenser

src/neon/deser.rs

@@ -1,9 +1,12 @@
 use crate::error::ErrorType;
 use crate::neon::stage1::bit_mask;
-use crate::stringparse::*;
+use crate::stringparse::{handle_unicode_codepoint, ESCAPE_MAP};
 use crate::Deserializer;
 use crate::Result;
-use std::arch::aarch64::*;
+use std::arch::aarch64::{
+    uint8x16_t, vandq_u8, vceqq_u8, vgetq_lane_u32, vld1q_u8, vmovq_n_u8, vpaddq_u8,
+    vreinterpretq_u32_u8,
+};
 
 #[cfg_attr(not(feature = "no-inline"), inline(always))]
 fn find_bs_bits_and_quote_bits(v0: uint8x16_t, v1: uint8x16_t) -> (u32, u32) {
@@ -51,7 +54,7 @@ impl<'de> Deserializer<'de> {
         buffer: &'invoke mut [u8],
         mut idx: usize,
     ) -> Result<&'de str> {
-        use ErrorType::*;
+        use ErrorType::{InvalidEscape, InvalidUnicodeCodepoint};
         let input: &mut [u8] = unsafe { std::mem::transmute(input) };
         // Add 1 to skip the initial "
         idx += 1;

src/neon/stage1.rs

@@ -1,5 +1,9 @@
-use crate::*;
-use std::arch::aarch64::*;
+use crate::{static_cast_i32, Stage1Parse};
+use std::arch::aarch64::{
+    int32x4_t, int8x16_t, uint8x16_t, vaddq_s32, vandq_u8, vceqq_u8, vcleq_u8, vdupq_n_s8,
+    vgetq_lane_u64, vld1q_u8, vmovq_n_u8, vmull_p64, vpaddq_u8, vqtbl1q_u8, vreinterpretq_u64_u8,
+    vreinterpretq_u8_s8, vshrq_n_u8, vtstq_u8,
+};
 use std::mem;
 
 // NEON-SPECIFIC
@@ -51,10 +55,10 @@ impl SimdInput {
     pub(crate) fn new(ptr: &[u8]) -> Self {
         unsafe {
             Self {
-                v0: vld1q_u8(ptr.as_ptr() as *const u8),
-                v1: vld1q_u8(ptr.as_ptr().add(16) as *const u8),
-                v2: vld1q_u8(ptr.as_ptr().add(32) as *const u8),
-                v3: vld1q_u8(ptr.as_ptr().add(48) as *const u8),
+                v0: vld1q_u8(ptr.as_ptr().cast::<u8>()),
+                v1: vld1q_u8(ptr.as_ptr().add(16).cast::<u8>()),
+                v2: vld1q_u8(ptr.as_ptr().add(32).cast::<u8>()),
+                v3: vld1q_u8(ptr.as_ptr().add(48).cast::<u8>()),
             }
         }
     }
@@ -66,8 +70,8 @@ impl Stage1Parse<int8x16_t> for SimdInput {
         unsafe {
             vgetq_lane_u64(
                 vreinterpretq_u64_u8(mem::transmute(vmull_p64(
-                    mem::transmute(-1 as i64),
-                    mem::transmute(quote_bits as i64),
+                    mem::transmute(-1_i64),
+                    mem::transmute(quote_bits),
                 ))),
                 0,
             )
@@ -178,7 +182,11 @@ impl Stage1Parse<int8x16_t> for SimdInput {
     // needs to be large enough to handle this
     //TODO: usize was u32 here does this matter?
     #[cfg_attr(not(feature = "no-inline"), inline(always))]
-    #[allow(clippy::cast_possible_wrap, clippy::cast_ptr_alignment)]
+    #[allow(
+        clippy::cast_possible_wrap,
+        clippy::cast_ptr_alignment,
+        clippy::uninit_vec
+    )]
     fn flatten_bits(base: &mut Vec<u32>, idx: u32, mut bits: u64) {
         let cnt: usize = bits.count_ones() as usize;
         let mut l = base.len();
@@ -215,7 +223,7 @@ impl Stage1Parse<int8x16_t> for SimdInput {
 
                 let v: int32x4_t = mem::transmute([v0, v1, v2, v3]);
                 let v: int32x4_t = vaddq_s32(idx_64_v, v);
-                std::ptr::write(base.as_mut_ptr().add(l) as *mut int32x4_t, v);
+                std::ptr::write(base.as_mut_ptr().add(l).cast::<int32x4_t>(), v);
             }
             l += 4;
         }

src/numberparse.rs

@@ -161,13 +161,14 @@ fn parse_eight_digits_unrolled(chars: &[u8]) -> u32 {
 
 #[cfg_attr(not(feature = "no-inline"), inline)]
 #[cfg(any(target_feature = "neon", target_feature = "simd128"))]
+#[allow(clippy::cast_ptr_alignment)]
 fn parse_eight_digits_unrolled(chars: &[u8]) -> u32 {
-    let val: u64 = unsafe { *(chars.as_ptr() as *const u64) };
+    let val: u64 = unsafe { *(chars.as_ptr().cast::<u64>()) };
     //    memcpy(&val, chars, sizeof(u64));
-    let val = (val & 0x0F0F0F0F0F0F0F0F).wrapping_mul(2561) >> 8;
-    let val = (val & 0x00FF00FF00FF00FF).wrapping_mul(6553601) >> 16;
+    let val = (val & 0x0F0F_0F0F_0F0F_0F0F).wrapping_mul(2561) >> 8;
+    let val = (val & 0x00FF_00FF_00FF_00FF).wrapping_mul(6_553_601) >> 16;
 
-    return ((val & 0x0000FFFF0000FFFF).wrapping_mul(42949672960001) >> 32) as u32;
+    ((val & 0x0000_FFFF_0000_FFFF).wrapping_mul(42_949_672_960_001) >> 32) as u32
 }
 
 impl<'de> Deserializer<'de> {