Skip to content
This repository has been archived by the owner on Feb 18, 2024. It is now read-only.

Commit

Permalink
Removed unused unsafe (#843)
Browse files Browse the repository at this point in the history
  • Loading branch information
@jorgecarleitao
jorgecarleitao authored Feb 15, 2022
1 parent 3b56b97 commit e0f98c7
Show file tree
Hide file tree
Showing 3 changed files with 58 additions and 73 deletions.
61 changes: 25 additions & 36 deletions src/compute/arithmetics/basic/div.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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<u64>` which means that
// T = u64
unsafe {
std::mem::transmute::<PrimitiveArray<u64>, PrimitiveArray<T>>(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::<PrimitiveArray<T>>()
.unwrap()
.clone()
}
PrimitiveType::UInt32 => {
let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u32>>().unwrap();
let rhs = rhs.to_u32().unwrap();

let reduced_div = StrengthReducedU32::new(rhs);
// Safety: we just proved that `lhs` is `PrimitiveArray<u32>` which means that
// T = u32
unsafe {
std::mem::transmute::<PrimitiveArray<u32>, PrimitiveArray<T>>(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::<PrimitiveArray<T>>()
.unwrap()
.clone()
}
PrimitiveType::UInt16 => {
let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u16>>().unwrap();
let rhs = rhs.to_u16().unwrap();

let reduced_div = StrengthReducedU16::new(rhs);
// Safety: we just proved that `lhs` is `PrimitiveArray<u16>` which means that
// T = u16
unsafe {
std::mem::transmute::<PrimitiveArray<u16>, PrimitiveArray<T>>(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::<PrimitiveArray<T>>()
.unwrap()
.clone()
}
PrimitiveType::UInt8 => {
let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u8>>().unwrap();
let rhs = rhs.to_u8().unwrap();

let reduced_div = StrengthReducedU8::new(rhs);
// Safety: we just proved that `lhs` is `PrimitiveArray<u8>` which means that
// T = u8
unsafe {
std::mem::transmute::<PrimitiveArray<u8>, PrimitiveArray<T>>(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::<PrimitiveArray<T>>()
.unwrap()
.clone()
}
_ => unary(lhs, |a| a / rhs, lhs.data_type().clone()),
}
Expand Down
68 changes: 32 additions & 36 deletions src/compute/arithmetics/basic/rem.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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<u64>` which means that
// T = u64
unsafe {
std::mem::transmute::<PrimitiveArray<u64>, PrimitiveArray<T>>(unary(
lhs,
|a| a % reduced_rem,
lhs.data_type().clone(),
))
}

// small hack to avoid a transmute of `PrimitiveArray<u64>` to `PrimitiveArray<T>`
let r = unary(lhs, |a| a % reduced_rem, lhs.data_type().clone());
(&r as &dyn Array)
.as_any()
.downcast_ref::<PrimitiveArray<T>>()
.unwrap()
.clone()
}
PrimitiveType::UInt32 => {
let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u32>>().unwrap();
let rhs = rhs.to_u32().unwrap();

let reduced_rem = StrengthReducedU32::new(rhs);
// Safety: we just proved that `lhs` is `PrimitiveArray<u32>` which means that
// T = u32
unsafe {
std::mem::transmute::<PrimitiveArray<u32>, PrimitiveArray<T>>(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<u64>` to `PrimitiveArray<T>`
(&r as &dyn Array)
.as_any()
.downcast_ref::<PrimitiveArray<T>>()
.unwrap()
.clone()
}
PrimitiveType::UInt16 => {
let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u16>>().unwrap();
let rhs = rhs.to_u16().unwrap();

let reduced_rem = StrengthReducedU16::new(rhs);
// Safety: we just proved that `lhs` is `PrimitiveArray<u16>` which means that
// T = u16
unsafe {
std::mem::transmute::<PrimitiveArray<u16>, PrimitiveArray<T>>(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<u16>` to `PrimitiveArray<T>`
(&r as &dyn Array)
.as_any()
.downcast_ref::<PrimitiveArray<T>>()
.unwrap()
.clone()
}
PrimitiveType::UInt8 => {
let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u8>>().unwrap();
let rhs = rhs.to_u8().unwrap();

let reduced_rem = StrengthReducedU8::new(rhs);
// Safety: we just proved that `lhs` is `PrimitiveArray<u8>` which means that
// T = u8
unsafe {
std::mem::transmute::<PrimitiveArray<u8>, PrimitiveArray<T>>(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<u8>` to `PrimitiveArray<T>`
(&r as &dyn Array)
.as_any()
.downcast_ref::<PrimitiveArray<T>>()
.unwrap()
.clone()
}
_ => unary(lhs, |a| a % rhs, lhs.data_type().clone()),
}
Expand Down
2 changes: 1 addition & 1 deletion src/compute/arithmetics/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down

0 comments on commit e0f98c7

Please sign in to comment.