Audit the error kinds for consistency and for wraps that lose them

A pass over all 3183 tagged sites, with the compiler doing the parts a text
scan cannot.

Tags. 17 messages carried different kinds at different sites. The rule
that settles each: a slot or buffer count is an InvalidArgument, never a
type error; a child index nobody can satisfy is OutOfBounds, whether it is
phrased as "invalid child index" or "has no child"; a check that a kernel
produced the declared length is AssertionFailed; and metadata checks are
Serde. 42 sites move, including the row-kernel input checks that were
InvalidArgument in one file and AssertionFailed in the next, and the view
bounds checks in VarBinView whose messages say "out of bounds". Four sites
that arrived with the rebase get their kinds.

Wraps. A `.map_err(|e| vortex_err!(Kind: "...: {e}"))` around a call that
already returns a VortexError replaces its kind with the wrapper's guess
and nests its whole Display, backtrace included, inside the new message. No
text scan can tell those from the same shape around an io::Error, so a
throwaway build probed every such closure with a marker type whose
must_use warning fires only when the wrapped value is a VortexError. It
found 10: the three statistics conversions, DType and union-scalar
deserialization, a CUDA scan column name, and four panics in test
harnesses. Each now uses `with_context`, or the `vortex_panic!(err, "...")`
form, which keep the kind. STYLE.md now says to do that.

From impls. `From<ArrowError>` sent every Arrow failure to Other. Arrow's
variants say what went wrong, so each now maps to its kind: NotYetImplemented
to NotImplemented, ArithmeticOverflow and the three offset overflows to
Overflow, SchemaError to MismatchedTypes, IoError to Io, the file-format
variants to Serde, and a rejected cast, parse or argument to
InvalidArgument. `From<jiff::Error>` maps a date that does not exist or a
misused unit, which jiff exposes as `is_range` and `is_invalid_parameter`,
to InvalidArgument. Both keep the original error as the source.

case_when's `serialize` said Serde for what is an unimplemented operation;
it is NotImplemented.

Signed-off-by: Robert Kruszewski <github@robertk.io>
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S7EtMqoZ91rrCCh9vS2yTm

Author: robert3005

STYLE.md

@@ -52,7 +52,17 @@
   - `vortex_err!` for creating errors
   - `vortex_bail!` for returning errors
   - `vortex_panic!` for handling invariant violations
-- Add context to errors using `.with_context()`
+- Every message names its `VortexErrorKind`, as in `vortex_bail!(InvalidArgument: "...")`; the
+  macros reject a message without one. Choose the kind by what went wrong, the way Python picks an
+  exception class: `InvalidArgument` (`ValueError`) for a value the callee rejects,
+  `MismatchedTypes` (`TypeError`) for the wrong dtype, `OutOfBounds` (`IndexError`) for a position
+  past the end, `NotFound` (`KeyError`) for a name that resolves to nothing, `Overflow`
+  (`OverflowError`) for a value that does not fit its target, `NotImplemented`, `Serde` for an
+  unreadable wire or file format, `Io` for a failed system or driver call, `AssertionFailed` for a
+  broken internal invariant, and `Other` only when nothing else fits. Never classify by where the
+  failure happened.
+- Add context to an existing error with `.with_context()`, which keeps its kind; do not format it
+  into a new `vortex_err!`, which discards the kind.
 - Include backtraces for better debugging
 - Use `VortexExpect` trait when unwrapping is appropriate with proper error context.
 

encodings/alp/src/alp/array.rs

@@ -310,7 +310,7 @@ impl ALPData {
                 Ok(DType::Primitive(PType::F64, *nullability))
             }
             _ => {
-                vortex_bail!(InvalidArgument: "ALP encoded ints have invalid DType {}", encoded.dtype(),)
+                vortex_bail!(MismatchedTypes: "ALP encoded ints have invalid DType {}", encoded.dtype(),)
             }
         }
     }

encodings/bytebool/src/array.rs

@@ -145,7 +145,7 @@ impl VTable for ByteBool {
         };
 
         if buffers.len() != 1 {
-            vortex_bail!(MismatchedTypes: "Expected 1 buffer, got {}", buffers.len());
+            vortex_bail!(InvalidArgument: "Expected 1 buffer, got {}", buffers.len());
         }
         let buffer = buffers[0].clone();
 

encodings/decimal-byte-parts/src/decimal_byte_parts/array.rs

@@ -219,7 +219,7 @@ impl VTable for DecimalByteParts {
             slots.len()
         );
         for (idx, slot) in slots.iter().enumerate() {
-            vortex_ensure!(slot.is_some(), NotFound: "missing required slot {idx}");
+            vortex_ensure!(slot.is_some(), InvalidArgument: "missing required slot {idx}");
         }
 
         let slots = DecimalBytePartsSlotsView::from_slots(slots);

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

@@ -188,7 +188,7 @@ impl VTable for BitPacked {
     ) -> VortexResult<ArrayParts<Self>> {
         let metadata = BitPackedMetadata::decode(metadata)?;
         if buffers.len() != 1 {
-            vortex_bail!(MismatchedTypes: "Expected 1 buffer, got {}", buffers.len());
+            vortex_bail!(InvalidArgument: "Expected 1 buffer, got {}", buffers.len());
         }
         let packed = buffers[0].clone();
 
@@ -200,7 +200,7 @@ impl VTable for BitPacked {
                 Ok(Validity::Array(validity))
             } else {
                 vortex_bail!(
-                    MismatchedTypes: "Expected {} or {} children, got {}",
+                    InvalidArgument: "Expected {} or {} children, got {}",
                     child_idx,
                     child_idx + 1,
                     children.len()

encodings/fastlanes/src/rle/probe.rs

@@ -31,7 +31,7 @@ pub(crate) fn scalar_at(
     let (mut retained, mut children) = state.split();
     let code = children
         .slot(RLESlots::INDICES)?
-        .ok_or_else(|| vortex_err!(NotFound: "RLE indices slot is missing"))?
+        .ok_or_else(|| vortex_err!(InvalidArgument: "RLE indices slot is missing"))?
         .execute_scalar(logical_index, ctx)?;
     let Some(code) = code.as_primitive().as_::<usize>() else {
         return Ok(Scalar::null(array.dtype().clone()));
@@ -47,7 +47,7 @@ pub(crate) fn scalar_at(
                 let value = read_offset(
                     children
                         .slot(RLESlots::VALUES_IDX_OFFSETS)?
-                        .ok_or_else(|| vortex_err!(NotFound: "RLE offsets slot is missing"))?
+                        .ok_or_else(|| vortex_err!(InvalidArgument: "RLE offsets slot is missing"))?
                         .execute_scalar(0, ctx)?,
                 )?;
                 if let Some(state) = retained.as_mut() {
@@ -59,7 +59,7 @@ pub(crate) fn scalar_at(
         read_offset(
             children
                 .slot(RLESlots::VALUES_IDX_OFFSETS)?
-                .ok_or_else(|| vortex_err!(NotFound: "RLE offsets slot is missing"))?
+                .ok_or_else(|| vortex_err!(InvalidArgument: "RLE offsets slot is missing"))?
                 .execute_scalar(chunk, ctx)?,
         )?
         .checked_sub(base)
@@ -70,7 +70,7 @@ pub(crate) fn scalar_at(
         .ok_or_else(|| vortex_err!(Overflow: "RLE value index overflow"))?;
     let scalar = children
         .slot(RLESlots::VALUES)?
-        .ok_or_else(|| vortex_err!(NotFound: "RLE values slot is missing"))?
+        .ok_or_else(|| vortex_err!(InvalidArgument: "RLE values slot is missing"))?
         .execute_scalar(value_index, ctx)?;
     Scalar::try_new(array.dtype().clone(), scalar.into_value())
 }

encodings/parquet-variant/src/vtable.rs

@@ -220,7 +220,7 @@ impl VTable for ParquetVariant {
             None => None,
         };
 
-        vortex_ensure!(matches!(dtype, DType::Variant(_)), InvalidArgument: "Expected Variant DType");
+        vortex_ensure!(matches!(dtype, DType::Variant(_)), MismatchedTypes: "Expected Variant DType");
         let has_typed_value = typed_value_dtype.is_some();
         vortex_ensure!(
             proto.has_value || has_typed_value,

encodings/runend/src/probe.rs

@@ -28,7 +28,7 @@ pub(crate) fn scalar_at(
     // between searches.
     let mut ends = state
         .slot(RunEndSlots::ENDS)?
-        .ok_or_else(|| vortex_err!(NotFound: "RunEnd ends slot is missing"))?;
+        .ok_or_else(|| vortex_err!(InvalidArgument: "RunEnd ends slot is missing"))?;
     let mut left = 0;
     let mut right = ends.array().len();
     while left < right {
@@ -42,7 +42,7 @@ pub(crate) fn scalar_at(
     }
     state
         .slot(RunEndSlots::VALUES)?
-        .ok_or_else(|| vortex_err!(NotFound: "RunEnd values slot is missing"))?
+        .ok_or_else(|| vortex_err!(InvalidArgument: "RunEnd values slot is missing"))?
         .execute_scalar(left, ctx)
 }
 

encodings/sparse/src/lib.rs

@@ -269,7 +269,7 @@ impl VTable for Sparse {
         // Once we have the patches metadata, we need to get the fill value from the buffers.
 
         if buffers.len() != 1 {
-            vortex_bail!(MismatchedTypes: "Expected 1 buffer, got {}", buffers.len());
+            vortex_bail!(InvalidArgument: "Expected 1 buffer, got {}", buffers.len());
         }
         let scalar_bytes: &[u8] = &buffers[0].clone().try_to_host_sync()?;
 

encodings/zstd/src/array.rs

@@ -1537,7 +1537,7 @@ impl ZstdData {
                     }
                 }
             }
-            _ => vortex_bail!(InvalidArgument: "Unsupported dtype for Zstd array: {}", dtype),
+            _ => vortex_bail!(MismatchedTypes: "Unsupported dtype for Zstd array: {}", dtype),
         }
     }