chore: #[inline] fns vortex-array (#4477)

Annotates small functions in vortex-array with `#[inline]` that could
benefit from cross crate inlining.

Signed-off-by: Alexander Droste <[email protected]>

Author: 0ax1

vortex-array/src/array/mod.rs

@@ -158,62 +158,77 @@ pub trait Array: 'static + private::Sealed + Send + Sync + Debug + ArrayVisitor
 }
 
 impl Array for Arc<dyn Array> {
+    #[inline]
     fn as_any(&self) -> &dyn Any {
         self.as_ref().as_any()
     }
 
+    #[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()
     }
 
+    #[inline]
     fn encoding(&self) -> EncodingRef {
         self.as_ref().encoding()
     }
 
+    #[inline]
     fn encoding_id(&self) -> EncodingId {
         self.as_ref().encoding_id()
     }
 
+    #[inline]
     fn slice(&self, range: Range<usize>) -> ArrayRef {
         self.as_ref().slice(range)
     }
 
+    #[inline]
     fn scalar_at(&self, index: usize) -> Scalar {
         self.as_ref().scalar_at(index)
     }
 
+    #[inline]
     fn is_valid(&self, index: usize) -> bool {
         self.as_ref().is_valid(index)
     }
 
+    #[inline]
     fn is_invalid(&self, index: usize) -> bool {
         self.as_ref().is_invalid(index)
     }
 
+    #[inline]
     fn all_valid(&self) -> bool {
         self.as_ref().all_valid()
     }
 
+    #[inline]
     fn all_invalid(&self) -> bool {
         self.as_ref().all_invalid()
     }
 
+    #[inline]
     fn valid_count(&self) -> usize {
         self.as_ref().valid_count()
     }
 
+    #[inline]
     fn invalid_count(&self) -> usize {
         self.as_ref().invalid_count()
     }
 
+    #[inline]
     fn validity_mask(&self) -> Mask {
         self.as_ref().validity_mask()
     }

vortex-array/src/iter.rs

@@ -21,6 +21,7 @@ pub trait ArrayIterator: Iterator<Item = VortexResult<ArrayRef>> {
 }
 
 impl ArrayIterator for Box<dyn ArrayIterator + Send> {
+    #[inline]
     fn dtype(&self) -> &DType {
         self.as_ref().dtype()
     }
@@ -32,6 +33,7 @@ pub struct ArrayIteratorAdapter<I> {
 }
 
 impl<I> ArrayIteratorAdapter<I> {
+    #[inline]
     pub fn new(dtype: DType, inner: I) -> Self {
         Self { dtype, inner }
     }
@@ -43,6 +45,7 @@ where
 {
     type Item = VortexResult<ArrayRef>;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next()
     }
@@ -52,6 +55,7 @@ impl<I> ArrayIterator for ArrayIteratorAdapter<I>
 where
     I: Iterator<Item = VortexResult<ArrayRef>>,
 {
+    #[inline]
     fn dtype(&self) -> &DType {
         &self.dtype
     }
@@ -107,6 +111,7 @@ enum ArrayChunkIterator {
 impl Iterator for ArrayChunkIterator {
     type Item = VortexResult<ArrayRef>;
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item> {
         match self {
             ArrayChunkIterator::Single(array) => array.take().map(Ok),

vortex-array/src/metadata.rs

@@ -74,6 +74,7 @@ pub struct ProstMetadata<M>(pub M);
 impl<M> Deref for ProstMetadata<M> {
     type Target = M;
 
+    #[inline]
     fn deref(&self) -> &Self::Target {
         &self.0
     }

vortex-array/src/partial_ord.rs

@@ -18,6 +18,7 @@ where
     }
 }
 
+#[inline]
 pub fn partial_min<T: PartialMin>(a: T, b: T) -> Option<T> {
     a.partial_min(b)
 }
@@ -41,6 +42,7 @@ where
 
 impl<T: PartialOrd> PartialMax for T {}
 
+#[inline]
 pub fn partial_max<T: PartialMax>(a: T, b: T) -> Option<T> {
     a.partial_max(b)
 }

vortex-array/src/patches.rs

@@ -37,6 +37,7 @@ pub struct PatchesMetadata {
 }
 
 impl PatchesMetadata {
+    #[inline]
     pub fn new(len: usize, offset: usize, indices_ptype: PType) -> Self {
         Self {
             len: len as u64,
@@ -134,46 +135,57 @@ impl Patches {
         }
     }
 
+    #[inline]
     pub fn array_len(&self) -> usize {
         self.array_len
     }
 
+    #[inline]
     pub fn num_patches(&self) -> usize {
         self.indices.len()
     }
 
+    #[inline]
     pub fn dtype(&self) -> &DType {
         self.values.dtype()
     }
 
+    #[inline]
     pub fn indices(&self) -> &ArrayRef {
         &self.indices
     }
 
+    #[inline]
     pub fn into_indices(self) -> ArrayRef {
         self.indices
     }
 
+    #[inline]
     pub fn indices_mut(&mut self) -> &mut ArrayRef {
         &mut self.indices
     }
 
+    #[inline]
     pub fn values(&self) -> &ArrayRef {
         &self.values
     }
 
+    #[inline]
     pub fn into_values(self) -> ArrayRef {
         self.values
     }
 
+    #[inline]
     pub fn values_mut(&mut self) -> &mut ArrayRef {
         &mut self.values
     }
 
+    #[inline]
     pub fn offset(&self) -> usize {
         self.offset
     }
 
+    #[inline]
     pub fn indices_ptype(&self) -> PType {
         PType::try_from(self.indices.dtype()).vortex_expect("primitive indices")
     }