chore: only use #[inline] for non-generic & public fns

Signed-off-by: Alexander Droste <alexander.droste@protonmail.com>

Author: 0ax1

encodings/alp/src/alp/mod.rs

@@ -89,7 +89,6 @@ pub trait ALPFloat: private::Sealed + Float + Display + NativePType {
     const IF10: &'static [Self];
 
     /// Round to the nearest floating integer by shifting in and out of the low precision range.
-    #[inline]
     fn fast_round(self) -> Self {
         (self + Self::SWEET) - Self::SWEET
     }
@@ -132,7 +131,6 @@ pub trait ALPFloat: private::Sealed + Float + Display + NativePType {
         best_exp
     }
 
-    #[inline]
     fn estimate_encoded_size(encoded: &[Self::ALPInt], patches: &[Self]) -> usize {
         let bits_per_encoded = encoded
             .iter()
@@ -204,7 +202,6 @@ pub trait ALPFloat: private::Sealed + Float + Display + NativePType {
         )
     }
 
-    #[inline]
     fn encode_single(value: Self, exponents: Exponents) -> Option<Self::ALPInt> {
         let encoded = Self::encode_single_unchecked(value, exponents);
         let decoded = Self::decode_single(encoded, exponents);

encodings/fastlanes/src/bit_transpose/aarch64.rs

@@ -114,7 +114,6 @@ static SCATTER_8X8_NEON: [[u8; 16]; 4] = [
 
 /// Perform 8x8 bit transpose on two u64s packed in a `uint64x2_t`.
 #[allow(unsafe_op_in_unsafe_fn)]
-#[inline]
 unsafe fn bit_transpose_8x8_neon(mut v: uint64x2_t) -> uint64x2_t {
     let mask1 = vdupq_n_u64(TRANSPOSE_2X2);
     let t = vandq_u64(veorq_u64(v, vshrq_n_u64::<7>(v)), mask1);

encodings/fastlanes/src/bit_transpose/scalar.rs

@@ -15,7 +15,6 @@ use crate::bit_transpose::TRANSPOSE_8X8;
 #[allow(dead_code)]
 pub fn transpose_bits_scalar(input: &[u8; 128], output: &mut [u8; 128]) {
     // Helper to perform 8x8 bit transpose on a u64 (each byte becomes a row)
-    #[inline]
     fn transpose_8x8(mut x: u64) -> u64 {
         // Step 1: Transpose 2x2 bit blocks
         let t = (x ^ (x >> 7)) & TRANSPOSE_2X2;
@@ -29,7 +28,6 @@ pub fn transpose_bits_scalar(input: &[u8; 128], output: &mut [u8; 128]) {
     }
 
     // Helper to gather 8 bytes at stride 16 into a u64
-    #[inline]
     fn gather(input: &[u8; 128], base: usize) -> u64 {
         u64::from(input[base])
             | (u64::from(input[base + 16]) << 8)
@@ -89,7 +87,6 @@ pub fn transpose_bits_scalar(input: &[u8; 128], output: &mut [u8; 128]) {
 #[inline(never)]
 #[allow(dead_code)]
 pub fn untranspose_bits_scalar(input: &[u8; 128], output: &mut [u8; 128]) {
-    #[inline]
     fn transpose_8x8(mut x: u64) -> u64 {
         let t = (x ^ (x >> 7)) & TRANSPOSE_2X2;
         x = x ^ t ^ (t << 7);
@@ -99,7 +96,6 @@ pub fn untranspose_bits_scalar(input: &[u8; 128], output: &mut [u8; 128]) {
         x ^ t ^ (t << 28)
     }
 
-    #[inline]
     fn gather_transposed(input: &[u8; 128], base_group: usize, offset: usize) -> u64 {
         let mut result: u64 = 0;
         for bit_pos in 0..8 {
@@ -108,7 +104,6 @@ pub fn untranspose_bits_scalar(input: &[u8; 128], output: &mut [u8; 128]) {
         result
     }
 
-    #[inline]
     fn scatter(output: &mut [u8; 128], base: usize, val: u64) {
         output[base] = val as u8;
         output[base + 16] = (val >> 8) as u8;

encodings/fastlanes/src/bit_transpose/x86.rs

@@ -49,7 +49,6 @@ pub fn has_vbmi() -> bool {
 #[allow(unsafe_op_in_unsafe_fn)]
 pub unsafe fn transpose_bits_bmi2(input: &[u8; 128], output: &mut [u8; 128]) {
     // Helper to gather 8 bytes at stride 16 into a u64
-    #[inline]
     fn gather(input: &[u8; 128], base: usize) -> u64 {
         (input[base] as u64)
             | ((input[base + 16] as u64) << 8)
@@ -238,7 +237,6 @@ pub unsafe fn transpose_bits_bmi2(input: &[u8; 128], output: &mut [u8; 128]) {
 #[allow(unsafe_op_in_unsafe_fn)]
 pub unsafe fn untranspose_bits_bmi2(input: &[u8; 128], output: &mut [u8; 128]) {
     // Helper: scatter a u64 to 8 output bytes at stride 16
-    #[inline]
     fn scatter(output: &mut [u8; 128], base: usize, val: u64) {
         output[base] = val as u8;
         output[base + 16] = (val >> 8) as u8;

encodings/fastlanes/src/bitpacking/array/mod.rs

@@ -210,7 +210,6 @@ impl BitPackedArray {
     }
 
     /// Access the slice of packed values as an array of `T`
-    #[inline]
     pub fn packed_slice<T: NativePType + BitPacking>(&self) -> &[T] {
         let packed_bytes = self.packed().as_host();
         let packed_ptr: *const T = packed_bytes.as_ptr().cast();

encodings/fastlanes/src/bitpacking/array/unpack_iter.rs

@@ -256,12 +256,10 @@ impl<T: PhysicalPType, S: UnpackStrategy<T>> UnpackedChunks<T, S> {
         })
     }
 
-    #[inline]
     fn last_chunk_is_sliced(&self) -> bool {
         self.last_chunk_length != 0
     }
 
-    #[inline]
     fn first_chunk_is_sliced(&self) -> bool {
         self.offset != 0
     }

encodings/runend/src/iter.rs

@@ -6,7 +6,6 @@ use std::cmp::min;
 use vortex_array::dtype::IntegerPType;
 use vortex_error::vortex_panic;
 
-#[inline]
 pub fn trimmed_ends_iter<E: IntegerPType>(
     run_ends: &[E],
     offset: usize,

encodings/sequence/src/compress.rs

@@ -30,7 +30,6 @@ struct SequenceIter<T> {
 impl<T: Copy + Add<Output = T>> Iterator for SequenceIter<T> {
     type Item = T;
 
-    #[inline]
     fn next(&mut self) -> Option<T> {
         if self.remaining == 0 {
             return None;
@@ -43,7 +42,6 @@ impl<T: Copy + Add<Output = T>> Iterator for SequenceIter<T> {
         Some(val)
     }
 
-    #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         (self.remaining, Some(self.remaining))
     }

vortex-array/src/aggregate_fn/fns/sum.rs

@@ -143,7 +143,6 @@ impl AggregateFnVTable for Sum {
         Ok(result)
     }
 
-    #[inline]
     fn is_saturated(&self, partial: &Self::Partial) -> bool {
         partial.current.is_none()
     }

vortex-array/src/array/mod.rs

@@ -168,7 +168,6 @@ pub trait DynArray:
 }
 
 impl DynArray for Arc<dyn DynArray> {
-    #[inline]
     fn as_any(&self) -> &dyn Any {
         DynArray::as_any(self.as_ref())
     }
@@ -177,17 +176,14 @@ impl DynArray for Arc<dyn DynArray> {
         self
     }
 
-    #[inline]
     fn to_array(&self) -> ArrayRef {
         self.clone()
     }
 
-    #[inline]
     fn len(&self) -> usize {
         self.as_ref().len()
     }
 
-    #[inline]
     fn dtype(&self) -> &DType {
         self.as_ref().dtype()
     }
@@ -196,12 +192,10 @@ impl DynArray for Arc<dyn DynArray> {
         self.as_ref().vtable()
     }
 
-    #[inline]
     fn encoding_id(&self) -> ArrayId {
         self.as_ref().encoding_id()
     }
 
-    #[inline]
     fn slice(&self, range: Range<usize>) -> VortexResult<ArrayRef> {
         self.as_ref().slice(range)
     }
@@ -214,47 +208,38 @@ impl DynArray for Arc<dyn DynArray> {
         self.as_ref().take(indices)
     }
 
-    #[inline]
     fn scalar_at(&self, index: usize) -> VortexResult<Scalar> {
         self.as_ref().scalar_at(index)
     }
 
-    #[inline]
     fn is_valid(&self, index: usize) -> VortexResult<bool> {
         self.as_ref().is_valid(index)
     }
 
-    #[inline]
     fn is_invalid(&self, index: usize) -> VortexResult<bool> {
         self.as_ref().is_invalid(index)
     }
 
-    #[inline]
     fn all_valid(&self) -> VortexResult<bool> {
         self.as_ref().all_valid()
     }
 
-    #[inline]
     fn all_invalid(&self) -> VortexResult<bool> {
         self.as_ref().all_invalid()
     }
 
-    #[inline]
     fn valid_count(&self) -> VortexResult<usize> {
         self.as_ref().valid_count()
     }
 
-    #[inline]
     fn invalid_count(&self) -> VortexResult<usize> {
         self.as_ref().invalid_count()
     }
 
-    #[inline]
     fn validity(&self) -> VortexResult<Validity> {
         self.as_ref().validity()
     }
 
-    #[inline]
     fn validity_mask(&self) -> VortexResult<Mask> {
         self.as_ref().validity_mask()
     }