fixes

Signed-off-by: Robert Kruszewski <github@robertk.io>

Author: robert3005

vortex-array/src/arrays/dict/array.rs

@@ -4,6 +4,7 @@
 use std::fmt::Display;
 use std::fmt::Formatter;
 
+use num_traits::AsPrimitive;
 use vortex_buffer::BitBuffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -133,7 +134,7 @@ pub trait DictArrayExt: TypedArrayRef<Dict> + DictArraySlotsExt {
             }
 
             let referenced_mask = self.compute_referenced_values_mask(true)?;
-            let all_referenced = referenced_mask.iter().all(|v| v);
+            let all_referenced = referenced_mask.true_count() == referenced_mask.len();
 
             vortex_ensure!(all_referenced, "value in dict not referenced");
         }
@@ -157,28 +158,19 @@ pub trait DictArrayExt: TypedArrayRef<Dict> + DictArraySlotsExt {
         match codes_validity.bit_buffer() {
             AllOr::All => {
                 match_each_integer_ptype!(codes_primitive.ptype(), |P| {
-                    #[allow(
-                        clippy::cast_possible_truncation,
-                        clippy::cast_sign_loss,
-                        reason = "codes are non-negative indices; a negative signed code would wrap to a large usize and panic on the bounds-checked array index"
-                    )]
-                    for &idx in codes_primitive.as_slice::<P>() {
-                        values_vec[idx as usize] = referenced_value;
+                    for idx in codes_primitive.as_slice::<P>() {
+                        let idxu: usize = idx.as_();
+                        values_vec[idxu] = referenced_value;
                     }
                 });
             }
             AllOr::None => {}
             AllOr::Some(mask) => {
                 match_each_integer_ptype!(codes_primitive.ptype(), |P| {
                     let codes = codes_primitive.as_slice::<P>();
-
-                    #[allow(
-                        clippy::cast_possible_truncation,
-                        clippy::cast_sign_loss,
-                        reason = "codes are non-negative indices; a negative signed code would wrap to a large usize and panic on the bounds-checked array index"
-                    )]
                     mask.set_indices().for_each(|idx| {
-                        values_vec[codes[idx] as usize] = referenced_value;
+                        let idxu: usize = codes[idx].as_();
+                        values_vec[idxu] = referenced_value;
                     });
                 });
             }

vortex-array/src/builders/dict/bytes.rs

@@ -175,14 +175,11 @@ impl<Code: UnsignedPType> BytesDictBuilder<Code> {
                     for (w, valid) in slice_offsets.windows(2).zip_eq(b.iter()) {
                         if !valid {
                             let code = self.null_code.get_or_init(|| {
+                                let code = self.views.len();
                                 self.views.push(BinaryView::default());
                                 self.values_nulls.append_false();
-                                Code::from_usize(self.values.len()).unwrap_or_else(|| {
-                                    vortex_panic!(
-                                        "{} has to fit into {}",
-                                        self.values.len(),
-                                        Code::PTYPE
-                                    )
+                                Code::from_usize(code).unwrap_or_else(|| {
+                                    vortex_panic!("{} has to fit into {}", code, Code::PTYPE)
                                 })
                             });
                             unsafe { codes.push_unchecked(*code) }
@@ -255,14 +252,11 @@ impl<Code: UnsignedPType> BytesDictBuilder<Code> {
                 for (view, valid) in views.iter().zip_eq(b.iter()) {
                     if !valid {
                         let code = self.null_code.get_or_init(|| {
+                            let code = self.views.len();
                             self.views.push(BinaryView::default());
                             self.values_nulls.append_false();
-                            Code::from_usize(self.values.len()).unwrap_or_else(|| {
-                                vortex_panic!(
-                                    "{} has to fit into {}",
-                                    self.values.len(),
-                                    Code::PTYPE
-                                )
+                            Code::from_usize(code).unwrap_or_else(|| {
+                                vortex_panic!("{} has to fit into {}", code, Code::PTYPE)
                             })
                         });
                         unsafe { codes.push_unchecked(*code) }

vortex-array/src/builders/dict/primitive.rs

@@ -146,14 +146,11 @@ where
                 for (&value, valid) in prim.as_slice::<T>().iter().zip(bit_buff) {
                     if !valid {
                         let code = self.null_code.get_or_init(|| {
+                            let code = self.values.len();
                             self.values.push(T::default());
                             self.values_nulls.append_false();
-                            Code::from_usize(self.values.len()).unwrap_or_else(|| {
-                                vortex_panic!(
-                                    "{} has to fit into {}",
-                                    self.values.len(),
-                                    Code::PTYPE
-                                )
+                            Code::from_usize(code).unwrap_or_else(|| {
+                                vortex_panic!("{} has to fit into {}", code, Code::PTYPE)
                             })
                         });
                         unsafe { codes.push_unchecked(*code) }