From ea528d203891c8d9117be28ea911babdb3f61983 Mon Sep 17 00:00:00 2001 From: Robert Kruszewski Date: Sun, 18 Jan 2026 09:31:26 +0000 Subject: [PATCH] chore: Small stylistic fixes to pointer casting Signed-off-by: Robert Kruszewski --- vortex-buffer/src/bit/view.rs | 2 +- vortex-compute/src/take/slice/portable.rs | 6 +++--- vortex-dtype/src/ptype.rs | 2 +- vortex-duckdb/src/convert/vector.rs | 2 +- vortex-duckdb/src/duckdb/object_cache.rs | 4 ++-- vortex-duckdb/src/duckdb/table_filter.rs | 2 +- vortex-duckdb/src/duckdb/vector.rs | 2 +- vortex-ffi/src/binary.rs | 8 ++++---- vortex-ffi/src/dtype.rs | 4 ++-- vortex-ffi/src/file.rs | 2 +- vortex-ffi/src/string.rs | 8 ++++---- vortex-scalar/src/scalar.rs | 4 ++-- vortex/benches/pipeline.rs | 6 +++--- 13 files changed, 26 insertions(+), 26 deletions(-) diff --git a/vortex-buffer/src/bit/view.rs b/vortex-buffer/src/bit/view.rs index 10964b2946e..1b05cd0c123 100644 --- a/vortex-buffer/src/bit/view.rs +++ b/vortex-buffer/src/bit/view.rs @@ -107,7 +107,7 @@ impl<'a, const NB: usize> BitView<'a, NB> { /// If the length of the slice is not equal to `NB`. pub fn from_slice(bits: &'a [u8]) -> Self { assert_eq!(bits.len(), NB); - let bits_array = unsafe { &*(bits.as_ptr() as *const [u8; NB]) }; + let bits_array = unsafe { &*(bits.as_ptr().cast::<[u8; NB]>()) }; BitView::new(bits_array) } diff --git a/vortex-compute/src/take/slice/portable.rs b/vortex-compute/src/take/slice/portable.rs index bc24e488870..71ca180ebcf 100644 --- a/vortex-compute/src/take/slice/portable.rs +++ b/vortex-compute/src/take/slice/portable.rs @@ -39,7 +39,7 @@ pub fn take_portable(buffer: &[T], indices: &[ // SAFETY: We know that f16 has the same bit pattern as u16, so this transmute is fine to // make. let u16_slice: &[u16] = - unsafe { std::slice::from_raw_parts(buffer.as_ptr() as *const u16, buffer.len()) }; + unsafe { std::slice::from_raw_parts(buffer.as_ptr().cast(), buffer.len()) }; return unsafe { take_with_indices(u16_slice, indices).transmute::() }; } @@ -49,7 +49,7 @@ pub fn take_portable(buffer: &[T], indices: &[ // SAFETY: This is essentially a no-op that tricks the compiler into adding the // `simd::SimdElement` bound we need to call `take_with_indices`. let buffer: &[TC] = - unsafe { std::slice::from_raw_parts(buffer.as_ptr() as *const TC, buffer.len()) }; + unsafe { std::slice::from_raw_parts(buffer.as_ptr().cast::(), buffer.len()) }; unsafe { take_with_indices(buffer, indices).transmute::() } }) } @@ -64,7 +64,7 @@ fn take_with_indices( ) -> Buffer { match_each_unsigned_integer_ptype!(I::PTYPE, |IC| { let indices: &[IC] = - unsafe { std::slice::from_raw_parts(indices.as_ptr() as *const IC, indices.len()) }; + unsafe { std::slice::from_raw_parts(indices.as_ptr().cast::(), indices.len()) }; take_portable_simd::(buffer, indices) }) } diff --git a/vortex-dtype/src/ptype.rs b/vortex-dtype/src/ptype.rs index e633c4f17b0..e8008beed90 100644 --- a/vortex-dtype/src/ptype.rs +++ b/vortex-dtype/src/ptype.rs @@ -895,7 +895,7 @@ macro_rules! try_from_bytes { fn to_le_bytes(&self) -> &[u8] { // NOTE(ngates): this assumes the platform is little-endian. Currently enforced // with a flag cfg(target_endian = "little") - let raw_ptr = self as *const $T as *const u8; + let raw_ptr = (self as *const $T).cast::(); unsafe { std::slice::from_raw_parts(raw_ptr, std::mem::size_of::<$T>()) } } } diff --git a/vortex-duckdb/src/convert/vector.rs b/vortex-duckdb/src/convert/vector.rs index 08ecc8781eb..7dbedc69813 100644 --- a/vortex-duckdb/src/convert/vector.rs +++ b/vortex-duckdb/src/convert/vector.rs @@ -62,7 +62,7 @@ impl<'a> DuckString<'a> { unsafe { let len = duckdb_string_t_length(*self.ptr); let c_ptr = duckdb_string_t_data(self.ptr); - std::slice::from_raw_parts(c_ptr as *const u8, len as usize) + std::slice::from_raw_parts(c_ptr.cast::(), len as usize) } } } diff --git a/vortex-duckdb/src/duckdb/object_cache.rs b/vortex-duckdb/src/duckdb/object_cache.rs index a635030ab86..b6e80ceee4c 100644 --- a/vortex-duckdb/src/duckdb/object_cache.rs +++ b/vortex-duckdb/src/duckdb/object_cache.rs @@ -38,7 +38,7 @@ impl ObjectCacheRef<'_> { cpp::duckdb_vx_object_cache_put( self.as_ptr(), key_cstr.as_ptr(), - opaque_ptr as *mut c_void, + opaque_ptr.cast(), Some(rust_box_deleter::), ); } @@ -55,7 +55,7 @@ impl ObjectCacheRef<'_> { unsafe { let opaque_ptr = cpp::duckdb_vx_object_cache_get(self.as_ptr(), key_cstr.as_ptr()); (!opaque_ptr.is_null()) - .then_some((opaque_ptr as *const T).as_ref()) + .then_some(opaque_ptr.cast::().as_ref()) .flatten() } } diff --git a/vortex-duckdb/src/duckdb/table_filter.rs b/vortex-duckdb/src/duckdb/table_filter.rs index c36f7f1f664..9b8ec5f1f1e 100644 --- a/vortex-duckdb/src/duckdb/table_filter.rs +++ b/vortex-duckdb/src/duckdb/table_filter.rs @@ -127,7 +127,7 @@ impl TableFilter { let name = unsafe { str::from_utf8_unchecked(std::slice::from_raw_parts( - out.child_name as *const u8, + out.child_name.cast::(), out.child_name_len, )) }; diff --git a/vortex-duckdb/src/duckdb/vector.rs b/vortex-duckdb/src/duckdb/vector.rs index e57ff10cf0b..14a7ab2fa69 100644 --- a/vortex-duckdb/src/duckdb/vector.rs +++ b/vortex-duckdb/src/duckdb/vector.rs @@ -144,7 +144,7 @@ impl Vector { // Direct bit manipulation for better performance let entry_idx = row / 64; let idx_in_entry = row % 64; - let validity_u64_ptr = validity as *const u64; + let validity_u64_ptr = validity.cast_const(); let validity_entry = unsafe { *validity_u64_ptr.add(entry_idx as usize) }; let is_valid = (validity_entry & (1u64 << idx_in_entry)) != 0; diff --git a/vortex-ffi/src/binary.rs b/vortex-ffi/src/binary.rs index 8f8c3d863f3..a13379787a7 100644 --- a/vortex-ffi/src/binary.rs +++ b/vortex-ffi/src/binary.rs @@ -46,7 +46,7 @@ mod tests { fn test_string_new() { unsafe { let test_str = "hello world"; - let ptr = test_str.as_ptr() as *const c_char; + let ptr = test_str.as_ptr().cast(); let len = test_str.len(); let vx_str = vx_binary_new(ptr, len); @@ -66,7 +66,7 @@ mod tests { let ptr = vx_binary_ptr(vx_str); let len = vx_binary_len(vx_str); - let slice = slice::from_raw_parts(ptr as *const u8, len); + let slice = slice::from_raw_parts(ptr.cast::(), len); assert_eq!(slice, "testing".as_bytes()); vx_binary_free(vx_str); @@ -77,7 +77,7 @@ mod tests { fn test_empty_string() { unsafe { let empty = ""; - let ptr = empty.as_ptr() as *const c_char; + let ptr = empty.as_ptr().cast(); let vx_str = vx_binary_new(ptr, 0); assert_eq!(vx_binary_len(vx_str), 0); @@ -91,7 +91,7 @@ mod tests { fn test_unicode_string() { unsafe { let unicode_str = "Hello δΈ–η•Œ 🌍"; - let ptr = unicode_str.as_ptr() as *const c_char; + let ptr = unicode_str.as_ptr().cast(); let len = unicode_str.len(); let vx_str = vx_binary_new(ptr, len); diff --git a/vortex-ffi/src/dtype.rs b/vortex-ffi/src/dtype.rs index 830409341b0..6684dc45ffd 100644 --- a/vortex-ffi/src/dtype.rs +++ b/vortex-ffi/src/dtype.rs @@ -660,7 +660,7 @@ mod tests { let name_len = unsafe { vx_string_len(field_name_ptr) }; let name_ptr = unsafe { vx_string_ptr(field_name_ptr) }; - let name_slice = unsafe { slice::from_raw_parts(name_ptr as *const u8, name_len) }; + let name_slice = unsafe { slice::from_raw_parts(name_ptr.cast::(), name_len) }; let name_str = str::from_utf8(name_slice).unwrap(); assert_eq!(name_str, "nums"); @@ -689,7 +689,7 @@ mod tests { let name_len = unsafe { vx_string_len(field_name_ptr) }; let name_ptr = unsafe { vx_string_ptr(field_name_ptr) }; - let name_slice = unsafe { slice::from_raw_parts(name_ptr as *const u8, name_len) }; + let name_slice = unsafe { slice::from_raw_parts(name_ptr.cast::(), name_len) }; let name_str = str::from_utf8(name_slice).unwrap(); let expected_name = if i == 0 { "nums" } else { "floats" }; diff --git a/vortex-ffi/src/file.rs b/vortex-ffi/src/file.rs index e38671b4716..77b3b95aa2a 100644 --- a/vortex-ffi/src/file.rs +++ b/vortex-ffi/src/file.rs @@ -114,7 +114,7 @@ fn extract_expression( ) -> VortexResult> { Ok((!expression.is_null() && expression_len > 0).then_some({ let bytes = - unsafe { slice::from_raw_parts(expression as *const u8, expression_len as usize) }; + unsafe { slice::from_raw_parts(expression.cast::(), expression_len as usize) }; // Decode the protobuf message. deserialize_expr_proto(&Expr::decode(bytes)?, registry) diff --git a/vortex-ffi/src/string.rs b/vortex-ffi/src/string.rs index 04c7f3c6f04..2be0d7b5c58 100644 --- a/vortex-ffi/src/string.rs +++ b/vortex-ffi/src/string.rs @@ -70,7 +70,7 @@ mod tests { fn test_string_new() { unsafe { let test_str = "hello world"; - let ptr = test_str.as_ptr() as *const c_char; + let ptr = test_str.as_ptr().cast(); let len = test_str.len(); let vx_str = vx_string_new(ptr, len); @@ -103,7 +103,7 @@ mod tests { let ptr = vx_string_ptr(vx_str); let len = vx_string_len(vx_str); - let slice = slice::from_raw_parts(ptr as *const u8, len); + let slice = slice::from_raw_parts(ptr.cast::(), len); let recovered = str::from_utf8_unchecked(slice); assert_eq!(recovered, "testing"); @@ -115,7 +115,7 @@ mod tests { fn test_empty_string() { unsafe { let empty = ""; - let ptr = empty.as_ptr() as *const c_char; + let ptr = empty.as_ptr().cast(); let vx_str = vx_string_new(ptr, 0); assert_eq!(vx_string_len(vx_str), 0); @@ -129,7 +129,7 @@ mod tests { fn test_unicode_string() { unsafe { let unicode_str = "Hello δΈ–η•Œ 🌍"; - let ptr = unicode_str.as_ptr() as *const c_char; + let ptr = unicode_str.as_ptr().cast(); let len = unicode_str.len(); let vx_str = vx_string_new(ptr, len); diff --git a/vortex-scalar/src/scalar.rs b/vortex-scalar/src/scalar.rs index b8ae15d8663..655c750c93d 100644 --- a/vortex-scalar/src/scalar.rs +++ b/vortex-scalar/src/scalar.rs @@ -186,7 +186,7 @@ impl Scalar { .ok() .flatten() .map_or(0, |s| s.len()), - DType::Struct(_dtype, _) => self + DType::Struct(..) => self .as_struct() .fields() .map(|fields| fields.into_iter().map(|f| f.nbytes()).sum::()) @@ -196,7 +196,7 @@ impl Scalar { .elements() .map(|fields| fields.into_iter().map(|f| f.nbytes()).sum::()) .unwrap_or_default(), - DType::Extension(_ext_dtype) => self.as_extension().storage().nbytes(), + DType::Extension(_) => self.as_extension().storage().nbytes(), } } diff --git a/vortex/benches/pipeline.rs b/vortex/benches/pipeline.rs index 64a443aab49..d34e89cc27d 100644 --- a/vortex/benches/pipeline.rs +++ b/vortex/benches/pipeline.rs @@ -680,7 +680,7 @@ fn alp_decompress(encoded: &[i32], exponents: Exponents, output: &mut [f32]) { /// This is safe because i32 and u32 have the same size and alignment. fn cast_i32_as_u32(slice: &[i32]) -> &[u32] { // SAFETY: i32 and u32 have the same size and alignment, so this transmute is safe. - unsafe { std::slice::from_raw_parts(slice.as_ptr() as *const u32, slice.len()) } + unsafe { std::slice::from_raw_parts(slice.as_ptr().cast(), slice.len()) } } /// Cast u32 slice to i32 slice. @@ -688,7 +688,7 @@ fn cast_i32_as_u32(slice: &[i32]) -> &[u32] { /// This is safe because u32 and i32 have the same size and alignment. fn cast_u32_as_i32(slice: &[u32]) -> &[i32] { // SAFETY: i32 and u32 have the same size and alignment, so this transmute is safe. - unsafe { std::slice::from_raw_parts(slice.as_ptr() as *const i32, slice.len()) } + unsafe { std::slice::from_raw_parts(slice.as_ptr().cast(), slice.len()) } } /// Cast mutable u32 slice to mutable i32 slice. @@ -696,7 +696,7 @@ fn cast_u32_as_i32(slice: &[u32]) -> &[i32] { /// This is safe because u32 and i32 have the same size and alignment. fn cast_u32_as_i32_mut(slice: &mut [u32]) -> &mut [i32] { // SAFETY: i32 and u32 have the same size and alignment, so this transmute is safe. - unsafe { std::slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut i32, slice.len()) } + unsafe { std::slice::from_raw_parts_mut(slice.as_mut_ptr().cast(), slice.len()) } } ////////////////////////////////////////////////////////////////////////////////////////////////////