Phase 1b

Signed-off-by: Nicholas Gates <nick@nickgates.com>

Author: gatesn

vortex-array/src/array/mod.rs

@@ -632,13 +632,16 @@ impl<V: VTable> DynArray for Array<V> {
     fn with_children(&self, children: Vec<ArrayRef>) -> VortexResult<ArrayRef> {
         let mut inner = self.array.clone();
         V::with_children(&mut inner, children)?;
-        Ok(Array::new(
-            self.typed_vtable().clone(),
-            self.dtype.clone(),
-            self.len,
-            inner,
-            self.stats.clone(),
-        )
+        // SAFETY: with_children preserves dtype and len.
+        Ok(unsafe {
+            Array::new_unchecked(
+                self.typed_vtable().clone(),
+                self.dtype.clone(),
+                self.len,
+                inner,
+                self.stats.clone(),
+            )
+        }
         .into_array())
     }
 }

vortex-array/src/vtable/dyn_.rs

@@ -101,13 +101,16 @@ impl<V: VTable> DynVTable for V {
             "Array dtype mismatch after building"
         );
         // Wrap in Array<V> for safe downcasting.
-        let array = Array::new(
-            self.clone(),
-            dtype.clone(),
-            len,
-            inner,
-            ArrayStats::default(),
-        );
+        // SAFETY: We just validated that V::len(&inner) == len and V::dtype(&inner) == dtype.
+        let array = unsafe {
+            Array::new_unchecked(
+                self.clone(),
+                dtype.clone(),
+                len,
+                inner,
+                ArrayStats::default(),
+            )
+        };
         Ok(array.into_array())
     }
 

vortex-array/src/vtable/mod.rs

@@ -238,7 +238,7 @@ pub fn patches_child_name(idx: usize) -> &'static str {
 /// vtable! macro — generates IntoArray, From, Deref, AsRef for inner array types.
 ///
 /// During the migration, IntoArray creates [`Array<V>`] (the new typed wrapper) while
-/// Deref/AsRef go through [`ArrayAdapter`] for backward-compatible DynArray access.
+/// Deref/AsRef go through AlsoArrayAdapter for backward-compatible DynArray access.
 #[macro_export]
 macro_rules! vtable {
     ($V:ident) => {
@@ -269,7 +269,10 @@ macro_rules! vtable {
                     let dtype = $VT::dtype(&self).clone();
                     let len = $VT::len(&self);
                     let stats = $VT::stats(&self).to_array_stats();
-                    std::sync::Arc::new($crate::vtable::Array::new(vtable, dtype, len, self, stats))
+                    // SAFETY: dtype and len are extracted from `self` via VTable methods.
+                    std::sync::Arc::new(unsafe {
+                        $crate::vtable::Array::new_unchecked(vtable, dtype, len, self, stats)
+                    })
                 }
             }
 

vortex-array/src/vtable/typed.rs

@@ -34,8 +34,18 @@ pub struct Array<V: VTable> {
 
 #[allow(clippy::same_name_method)]
 impl<V: VTable> Array<V> {
-    /// Create a new typed array.
-    pub fn new(vtable: V, dtype: DType, len: usize, array: V::Array, stats: ArrayStats) -> Self {
+    /// Create a new typed array without validating that the inner array's dtype/len match.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `V::dtype(&array) == &dtype` and `V::len(&array) == len`.
+    pub unsafe fn new_unchecked(
+        vtable: V,
+        dtype: DType,
+        len: usize,
+        array: V::Array,
+        stats: ArrayStats,
+    ) -> Self {
         Self {
             vtable,
             dtype,

vortex-python/src/arrays/native.rs

@@ -21,6 +21,7 @@ use vortex::array::arrays::Primitive;
 use vortex::array::arrays::Struct;
 use vortex::array::arrays::VarBin;
 use vortex::array::arrays::VarBinView;
+use vortex::array::vtable::Array;
 use vortex::array::vtable::VTable;
 use vortex::encodings::alp::ALP;
 use vortex::encodings::alp::ALPRD;
@@ -251,10 +252,12 @@ pub trait AsArrayRef<T> {
 
 impl<V: EncodingSubclass> AsArrayRef<<V::VTable as VTable>::Array> for PyRef<'_, V> {
     fn as_array_ref(&self) -> &<V::VTable as VTable>::Array {
-        self.as_super()
-            .inner()
-            .as_any()
-            .downcast_ref::<ArrayAdapter<V::VTable>>()
+        let any = self.as_super().inner().as_any();
+        // Try new Array<V> path first, then fall back to legacy ArrayAdapter<V>.
+        if let Some(typed) = any.downcast_ref::<Array<V::VTable>>() {
+            return typed.inner();
+        }
+        any.downcast_ref::<ArrayAdapter<V::VTable>>()
             .vortex_expect("Failed to downcast array")
             .as_inner()
     }