From 42e625eed7ba6d0b3a716295120f7c08e11aa3a4 Mon Sep 17 00:00:00 2001 From: "Jorge C. Leitao" Date: Tue, 15 Feb 2022 17:10:17 +0000 Subject: [PATCH] Removed unused unsafe --- src/compute/arithmetics/basic/div.rs | 61 ++++++++++--------------- src/compute/arithmetics/basic/rem.rs | 68 +++++++++++++--------------- src/compute/arithmetics/mod.rs | 2 +- 3 files changed, 58 insertions(+), 73 deletions(-) diff --git a/src/compute/arithmetics/basic/div.rs b/src/compute/arithmetics/basic/div.rs index 77d65e8f88f..b7f22a0d771 100644 --- a/src/compute/arithmetics/basic/div.rs +++ b/src/compute/arithmetics/basic/div.rs @@ -117,60 +117,49 @@ where let rhs = rhs.to_u64().unwrap(); let reduced_div = StrengthReducedU64::new(rhs); - // Safety: we just proved that `lhs` is `PrimitiveArray` which means that - // T = u64 - unsafe { - std::mem::transmute::, PrimitiveArray>(unary( - lhs, - |a| a / reduced_div, - lhs.data_type().clone(), - )) - } + let r = unary(lhs, |a| a / reduced_div, lhs.data_type().clone()); + (&r as &dyn Array) + .as_any() + .downcast_ref::>() + .unwrap() + .clone() } PrimitiveType::UInt32 => { let lhs = lhs.as_any().downcast_ref::>().unwrap(); let rhs = rhs.to_u32().unwrap(); let reduced_div = StrengthReducedU32::new(rhs); - // Safety: we just proved that `lhs` is `PrimitiveArray` which means that - // T = u32 - unsafe { - std::mem::transmute::, PrimitiveArray>(unary( - lhs, - |a| a / reduced_div, - lhs.data_type().clone(), - )) - } + let r = unary(lhs, |a| a / reduced_div, lhs.data_type().clone()); + (&r as &dyn Array) + .as_any() + .downcast_ref::>() + .unwrap() + .clone() } PrimitiveType::UInt16 => { let lhs = lhs.as_any().downcast_ref::>().unwrap(); let rhs = rhs.to_u16().unwrap(); let reduced_div = StrengthReducedU16::new(rhs); - // Safety: we just proved that `lhs` is `PrimitiveArray` which means that - // T = u16 - unsafe { - std::mem::transmute::, PrimitiveArray>(unary( - lhs, - |a| a / reduced_div, - lhs.data_type().clone(), - )) - } + + let r = unary(lhs, |a| a / reduced_div, lhs.data_type().clone()); + (&r as &dyn Array) + .as_any() + .downcast_ref::>() + .unwrap() + .clone() } PrimitiveType::UInt8 => { let lhs = lhs.as_any().downcast_ref::>().unwrap(); let rhs = rhs.to_u8().unwrap(); let reduced_div = StrengthReducedU8::new(rhs); - // Safety: we just proved that `lhs` is `PrimitiveArray` which means that - // T = u8 - unsafe { - std::mem::transmute::, PrimitiveArray>(unary( - lhs, - |a| a / reduced_div, - lhs.data_type().clone(), - )) - } + let r = unary(lhs, |a| a / reduced_div, lhs.data_type().clone()); + (&r as &dyn Array) + .as_any() + .downcast_ref::>() + .unwrap() + .clone() } _ => unary(lhs, |a| a / rhs, lhs.data_type().clone()), } diff --git a/src/compute/arithmetics/basic/rem.rs b/src/compute/arithmetics/basic/rem.rs index 0d37169ef77..79a6055b8fd 100644 --- a/src/compute/arithmetics/basic/rem.rs +++ b/src/compute/arithmetics/basic/rem.rs @@ -104,60 +104,56 @@ where let rhs = rhs.to_u64().unwrap(); let reduced_rem = StrengthReducedU64::new(rhs); - // Safety: we just proved that `lhs` is `PrimitiveArray` which means that - // T = u64 - unsafe { - std::mem::transmute::, PrimitiveArray>(unary( - lhs, - |a| a % reduced_rem, - lhs.data_type().clone(), - )) - } + + // small hack to avoid a transmute of `PrimitiveArray` to `PrimitiveArray` + let r = unary(lhs, |a| a % reduced_rem, lhs.data_type().clone()); + (&r as &dyn Array) + .as_any() + .downcast_ref::>() + .unwrap() + .clone() } PrimitiveType::UInt32 => { let lhs = lhs.as_any().downcast_ref::>().unwrap(); let rhs = rhs.to_u32().unwrap(); let reduced_rem = StrengthReducedU32::new(rhs); - // Safety: we just proved that `lhs` is `PrimitiveArray` which means that - // T = u32 - unsafe { - std::mem::transmute::, PrimitiveArray>(unary( - lhs, - |a| a % reduced_rem, - lhs.data_type().clone(), - )) - } + + let r = unary(lhs, |a| a % reduced_rem, lhs.data_type().clone()); + // small hack to avoid an unsafe transmute of `PrimitiveArray` to `PrimitiveArray` + (&r as &dyn Array) + .as_any() + .downcast_ref::>() + .unwrap() + .clone() } PrimitiveType::UInt16 => { let lhs = lhs.as_any().downcast_ref::>().unwrap(); let rhs = rhs.to_u16().unwrap(); let reduced_rem = StrengthReducedU16::new(rhs); - // Safety: we just proved that `lhs` is `PrimitiveArray` which means that - // T = u16 - unsafe { - std::mem::transmute::, PrimitiveArray>(unary( - lhs, - |a| a % reduced_rem, - lhs.data_type().clone(), - )) - } + + let r = unary(lhs, |a| a % reduced_rem, lhs.data_type().clone()); + // small hack to avoid an unsafe transmute of `PrimitiveArray` to `PrimitiveArray` + (&r as &dyn Array) + .as_any() + .downcast_ref::>() + .unwrap() + .clone() } PrimitiveType::UInt8 => { let lhs = lhs.as_any().downcast_ref::>().unwrap(); let rhs = rhs.to_u8().unwrap(); let reduced_rem = StrengthReducedU8::new(rhs); - // Safety: we just proved that `lhs` is `PrimitiveArray` which means that - // T = u8 - unsafe { - std::mem::transmute::, PrimitiveArray>(unary( - lhs, - |a| a % reduced_rem, - lhs.data_type().clone(), - )) - } + + let r = unary(lhs, |a| a % reduced_rem, lhs.data_type().clone()); + // small hack to avoid an unsafe transmute of `PrimitiveArray` to `PrimitiveArray` + (&r as &dyn Array) + .as_any() + .downcast_ref::>() + .unwrap() + .clone() } _ => unary(lhs, |a| a % rhs, lhs.data_type().clone()), } diff --git a/src/compute/arithmetics/mod.rs b/src/compute/arithmetics/mod.rs index 34ab0bf1722..5766385d8a4 100644 --- a/src/compute/arithmetics/mod.rs +++ b/src/compute/arithmetics/mod.rs @@ -11,7 +11,7 @@ //! * overflowing: returns an extra [`Bitmap`] denoting whether the operation overflowed. //! * adaptive: for [`Decimal`](crate::datatypes::DataType::Decimal) only, //! adjusts the precision and scale to make the resulting value fit. - +#[forbid(unsafe_code)] pub mod basic; pub mod decimal; pub mod time;