Remove error kinds from VortexError

A VortexError is now a message, an optional source and a backtrace. The
VortexErrorKind classification is gone, and with it kind(), the kind
prefix in the displayed message and the classification of foreign errors
in the From impls, which now keep the foreign error as the source.

The error macros take a plain format string again. The Context: and
External: forms remain, since they are not kinds. Every call site drops
its kind tag, and vortex_ensure_eq! loses its kind-only form.

Tests that asserted on a kind now assert on the guard's message.

The Python bindings raise RuntimeError for every Vortex error, as before
kinds existed. The C API keeps VX_ERROR_CODE_OTHER for Vortex errors and
VX_ERROR_CODE_PANIC for panics, at their existing values, and the C++
ErrorCode mirrors it.

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

Author: robert3005

STYLE.md

@@ -54,20 +54,9 @@
   - `vortex_panic!` for handling invariant violations
   - `vortex_ensure!` and `vortex_ensure_eq!` for checking conditions. Prefer
     `vortex_ensure_eq!(a, b)` with no message: the error already shows both expressions and values.
-    Add a message only for context the expressions lack, and never repeat the values in it. With no
-    message the error is `AssertionFailed`; when the check is on the caller's input rather than an
-    internal invariant, name the kind alone, as in `vortex_ensure_eq!(a, b, InvalidArgument)`.
-- 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.
+    Add a message only for context the expressions lack, and never repeat the values in it.
+- Add context to an existing error with `.with_context()`, which keeps its source and backtrace;
+  do not format it into a new `vortex_err!`, which discards them.
 - Include backtraces for better debugging
 - Use `VortexExpect` trait when unwrapping is appropriate with proper error context.
 

encodings/alp/src/alp/array.rs

@@ -98,7 +98,7 @@ impl VTable for ALP {
     }
 
     fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
-        vortex_panic!(OutOfBounds: "ALPArray buffer index {idx} out of bounds")
+        vortex_panic!("ALPArray buffer index {idx} out of bounds")
     }
 
     fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
@@ -144,7 +144,7 @@ impl VTable for ALP {
         let encoded_ptype = match &dtype {
             DType::Primitive(PType::F32, n) => DType::Primitive(PType::I32, *n),
             DType::Primitive(PType::F64, n) => DType::Primitive(PType::I64, *n),
-            d => vortex_bail!(MismatchedTypes: "expected type: f32 or f64 but instead got {}", d),
+            d => vortex_bail!("expected type: f32 or f64 but instead got {}", d),
         };
         let encoded = children.get(0, &encoded_ptype, len)?;
 
@@ -275,7 +275,7 @@ impl ALPData {
                 encoded.dtype(),
                 DType::Primitive(PType::I32 | PType::I64, _)
             ),
-            MismatchedTypes: "ALP encoded ints have invalid DType {}",
+            "ALP encoded ints have invalid DType {}",
             encoded.dtype(),
         );
 
@@ -284,15 +284,15 @@ impl ALPData {
         let Exponents { e, f } = exponents;
         match encoded.dtype().as_ptype() {
             PType::I32 => {
-                vortex_ensure!(exponents.e <= f32::MAX_EXPONENT, InvalidArgument: "e out of bounds: {e}");
-                vortex_ensure!(exponents.f <= f32::MAX_EXPONENT, InvalidArgument: "f out of bounds: {f}");
+                vortex_ensure!(exponents.e <= f32::MAX_EXPONENT, "e out of bounds: {e}");
+                vortex_ensure!(exponents.f <= f32::MAX_EXPONENT, "f out of bounds: {f}");
                 if let Some(patches) = patches {
                     Self::validate_patches::<f32>(patches, encoded)?;
                 }
             }
             PType::I64 => {
-                vortex_ensure!(e <= f64::MAX_EXPONENT, InvalidArgument: "e out of bounds: {e}");
-                vortex_ensure!(f <= f64::MAX_EXPONENT, InvalidArgument: "f out of bounds: {f}");
+                vortex_ensure!(e <= f64::MAX_EXPONENT, "e out of bounds: {e}");
+                vortex_ensure!(f <= f64::MAX_EXPONENT, "f out of bounds: {f}");
 
                 if let Some(patches) = patches {
                     Self::validate_patches::<f64>(patches, encoded)?;
@@ -303,7 +303,7 @@ impl ALPData {
 
         // Validate patches
         if let Some(patches) = patches {
-            vortex_ensure_eq!(patches.array_len(), encoded.len(), InvalidArgument);
+            vortex_ensure_eq!(patches.array_len(), encoded.len());
 
             // Verify that the patches DType are of the proper DType.
         }
@@ -320,7 +320,7 @@ impl ALPData {
                 Ok(DType::Primitive(PType::F64, *nullability))
             }
             _ => {
-                vortex_bail!(MismatchedTypes: "ALP encoded ints have invalid DType {}", encoded.dtype(),)
+                vortex_bail!("ALP encoded ints have invalid DType {}", encoded.dtype(),)
             }
         }
     }
@@ -330,10 +330,10 @@ impl ALPData {
         patches: &Patches,
         encoded: &ArrayRef,
     ) -> VortexResult<()> {
-        vortex_ensure_eq!(patches.array_len(), encoded.len(), InvalidArgument);
+        vortex_ensure_eq!(patches.array_len(), encoded.len());
 
         let expected_type = DType::Primitive(T::PTYPE, encoded.dtype().nullability());
-        vortex_ensure_eq!(patches.dtype(), &expected_type, MismatchedTypes);
+        vortex_ensure_eq!(patches.dtype(), &expected_type);
 
         Ok(())
     }
@@ -447,11 +447,11 @@ fn validate_parts(
 ) -> VortexResult<()> {
     let logical_dtype = ALPData::logical_dtype(encoded)?;
     ALPData::validate_components(encoded, exponents, patches.as_ref())?;
-    vortex_ensure_eq!(encoded.len(), len, InvalidArgument: "ALP encoded len must match outer len");
+    vortex_ensure_eq!(encoded.len(), len, "ALP encoded len must match outer len");
     vortex_ensure_eq!(
         &logical_dtype,
         dtype,
-        MismatchedTypes: "ALP dtype does not match encoded logical dtype"
+        "ALP dtype does not match encoded logical dtype"
     );
     Ok(())
 }

encodings/alp/src/alp/compress.rs

@@ -39,7 +39,7 @@ macro_rules! match_each_alp_float_ptype {
                 type $enc = f64;
                 $body
             }
-            _ => vortex_panic!(MismatchedTypes: "ALP can only encode f32 and f64, got {}", ptype),
+            _ => vortex_panic!("ALP can only encode f32 and f64, got {}", ptype),
         }
     }};
 }
@@ -52,7 +52,7 @@ pub fn alp_encode(
     let (exponents, encoded, patches) = match parray.ptype() {
         PType::F32 => alp_encode_components_typed::<f32>(parray, exponents, ctx)?,
         PType::F64 => alp_encode_components_typed::<f64>(parray, exponents, ctx)?,
-        _ => vortex_bail!(MismatchedTypes: "ALP can only encode f32 and f64"),
+        _ => vortex_bail!("ALP can only encode f32 and f64"),
     };
 
     // SAFETY: alp_encode_components_typed must return well-formed components

encodings/alp/src/alp/compute/compare.rs

@@ -45,7 +45,7 @@ impl CompareKernel for ALP {
         if let Some(const_scalar) = rhs.as_constant() {
             let pscalar = const_scalar.as_primitive_opt().ok_or_else(|| {
                 vortex_err!(
-                    InvalidArgument: "ALP Compare RHS had the wrong type {}, expected {}",
+                    "ALP Compare RHS had the wrong type {}, expected {}",
                     const_scalar,
                     const_scalar.dtype()
                 )
@@ -55,7 +55,7 @@ impl CompareKernel for ALP {
                 match pscalar.typed_value::<T>() {
                     Some(value) => return alp_scalar_compare(lhs, value, operator),
                     None => vortex_bail!(
-                        InvalidArgument: "Failed to convert scalar {:?} to ALP type {:?}",
+                        "Failed to convert scalar {:?} to ALP type {:?}",
                         pscalar,
                         pscalar.ptype()
                     ),

encodings/alp/src/alp/ops.rs

@@ -36,7 +36,7 @@ impl OperationsVTable<ALP> for ALP {
 
         let encoded_val = state
             .slot(ALPSlots::ENCODED)?
-            .ok_or_else(|| vortex_err!(InvalidArgument: "ALP encoded slot is missing"))?
+            .ok_or_else(|| vortex_err!("ALP encoded slot is missing"))?
             .execute_scalar(index, ctx)?;
 
         Ok(match_each_alp_float_ptype!(array.dtype().as_ptype(), |T| {

encodings/alp/src/alp/plugin.rs

@@ -55,7 +55,7 @@ impl ArrayPlugin for ALPPatchedPlugin {
         vortex_ensure_eq!(
             parts.serialized_id,
             self.id(),
-            Serde: "ALP plugin does not recognize serialized ID"
+            "ALP plugin does not recognize serialized ID"
         );
         let alp_array = Array::<ALP>::try_from_parts(ArrayVTable::deserialize(
             &ALP,
@@ -66,7 +66,7 @@ impl ArrayPlugin for ALPPatchedPlugin {
             parts.children,
             session,
         )?)
-        .map_err(|_| vortex_err!(Serde: "ALP plugin should only deserialize vortex.alp"))?;
+        .map_err(|_| vortex_err!("ALP plugin should only deserialize vortex.alp"))?;
 
         // Check if there are interior patches to externalize.
         let Some(patches) = alp_array.patches() else {
@@ -164,13 +164,15 @@ mod tests {
 
         assert_arrays_eq!(deserialized, parray, &mut SESSION.create_execution_ctx());
 
-        let patched: PatchedArray = deserialized.try_downcast().map_err(
-            |a| vortex_err!(MismatchedTypes: "Expected Patched, got {}", a.encoding_id()),
-        )?;
+        let patched: PatchedArray = deserialized
+            .try_downcast()
+            .map_err(|a| vortex_err!("Expected Patched, got {}", a.encoding_id()))?;
 
-        let inner_alp: ALPArray = patched.inner().clone().try_downcast().map_err(
-            |a| vortex_err!(MismatchedTypes: "Expected inner ALP, got {}", a.encoding_id()),
-        )?;
+        let inner_alp: ALPArray = patched
+            .inner()
+            .clone()
+            .try_downcast()
+            .map_err(|a| vortex_err!("Expected inner ALP, got {}", a.encoding_id()))?;
 
         assert!(
             inner_alp.patches().is_none(),
@@ -216,9 +218,9 @@ mod tests {
 
         assert_arrays_eq!(deserialized, parray, &mut SESSION.create_execution_ctx());
 
-        let result = deserialized.try_downcast::<ALP>().map_err(
-            |a| vortex_err!(Serde: "Expected deserialized ALP, got {}", a.encoding_id()),
-        )?;
+        let result = deserialized
+            .try_downcast::<ALP>()
+            .map_err(|a| vortex_err!("Expected deserialized ALP, got {}", a.encoding_id()))?;
 
         assert!(result.patches().is_none(), "Result should not have patches");
 

encodings/alp/src/alp_rd/array.rs

@@ -122,7 +122,7 @@ impl VTable for ALPRD {
     }
 
     fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
-        vortex_panic!(OutOfBounds: "ALPRDArray buffer index {idx} out of bounds")
+        vortex_panic!("ALPRDArray buffer index {idx} out of bounds")
     }
 
     fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
@@ -174,7 +174,7 @@ impl VTable for ALPRD {
         let metadata = ALPRDMetadata::decode(metadata)?;
         if children.len() < 2 {
             vortex_bail!(
-                InvalidArgument: "Expected at least 2 children for ALPRD encoding, found {}",
+                "Expected at least 2 children for ALPRD encoding, found {}",
                 children.len()
             );
         }
@@ -185,9 +185,8 @@ impl VTable for ALPRD {
             [0..metadata.dict_len as usize]
             .iter()
             .map(|&i| {
-                u16::try_from(i).map_err(
-                    |_| vortex_err!(Overflow: "left_parts_dictionary code {i} does not fit in u16"),
-                )
+                u16::try_from(i)
+                    .map_err(|_| vortex_err!("left_parts_dictionary code {i} does not fit in u16"))
             })
             .try_collect()?;
 
@@ -198,7 +197,7 @@ impl VTable for ALPRD {
             DType::Primitive(PType::F64, _) => {
                 DType::Primitive(PType::U64, Nullability::NonNullable)
             }
-            _ => vortex_bail!(MismatchedTypes: "Expected f32 or f64 dtype, got {:?}", dtype),
+            _ => vortex_bail!("Expected f32 or f64 dtype, got {:?}", dtype),
         };
         let right_parts = children.get(1, &right_parts_dtype, len)?;
 
@@ -224,7 +223,7 @@ impl VTable for ALPRD {
             left_parts_dictionary,
             u8::try_from(metadata.right_bit_width).map_err(|_| {
                 vortex_err!(
-                    Overflow: "right_bit_width {} out of u8 range",
+                    "right_bit_width {} out of u8 range",
                     metadata.right_bit_width
                 )
             })?,
@@ -478,18 +477,18 @@ fn validate_parts(
     left_parts_patches: Option<&Patches>,
 ) -> VortexResult<()> {
     if !dtype.is_float() {
-        vortex_bail!(InvalidArgument: "ALPRDArray given invalid DType ({dtype})");
+        vortex_bail!("ALPRDArray given invalid DType ({dtype})");
     }
 
-    vortex_ensure_eq!(left_parts.len(), len, InvalidArgument);
-    vortex_ensure_eq!(right_parts.len(), len, InvalidArgument);
+    vortex_ensure_eq!(left_parts.len(), len);
+    vortex_ensure_eq!(right_parts.len(), len);
 
     if !left_parts.dtype().is_unsigned_int() {
-        vortex_bail!(InvalidArgument: "left_parts dtype must be uint");
+        vortex_bail!("left_parts dtype must be uint");
     }
     if dtype.is_nullable() != left_parts.dtype().is_nullable() {
         vortex_bail!(
-            InvalidArgument: "ALPRDArray dtype nullability ({}) must match left_parts dtype nullability ({})",
+            "ALPRDArray dtype nullability ({}) must match left_parts dtype nullability ({})",
             dtype,
             left_parts.dtype()
         );
@@ -498,16 +497,12 @@ fn validate_parts(
     let expected_right_parts_dtype = match dtype {
         DType::Primitive(PType::F32, _) => DType::Primitive(PType::U32, Nullability::NonNullable),
         DType::Primitive(PType::F64, _) => DType::Primitive(PType::U64, Nullability::NonNullable),
-        _ => vortex_bail!(MismatchedTypes: "Expected f32 or f64 dtype, got {:?}", dtype),
+        _ => vortex_bail!("Expected f32 or f64 dtype, got {:?}", dtype),
     };
-    vortex_ensure_eq!(
-        right_parts.dtype(),
-        &expected_right_parts_dtype,
-        MismatchedTypes
-    );
+    vortex_ensure_eq!(right_parts.dtype(), &expected_right_parts_dtype);
 
     if let Some(patches) = left_parts_patches {
-        vortex_ensure_eq!(patches.array_len(), len, InvalidArgument);
+        vortex_ensure_eq!(patches.array_len(), len);
         // Left-parts exceptions are always all-valid and are stored as the non-nullable left-parts
         // dtype. Requiring that exact dtype (rather than ignoring nullability) means each
         // construction path must produce correct patches, removing the need to normalize them.
@@ -516,7 +511,7 @@ fn validate_parts(
         vortex_ensure_eq!(
             patches.dtype(),
             &expected,
-            MismatchedTypes: "patches dtype must be the non-nullable left_parts dtype"
+            "patches dtype must be the non-nullable left_parts dtype"
         );
     }
 

encodings/alp/src/alp_rd/mod.rs

@@ -150,7 +150,7 @@ where
     T::UINT: NativePType,
 {
     if left_parts.len() != right_parts.len() {
-        vortex_panic!(AssertionFailed: "alp_rd_decode: left_parts.len != right_parts.len");
+        vortex_panic!("alp_rd_decode: left_parts.len != right_parts.len");
     }
 
     if let Some(patches) = left_parts_patches {

encodings/bytebool/src/array.rs

@@ -85,14 +85,14 @@ impl VTable for ByteBool {
     fn buffer(array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
         match idx {
             0 => array.buffer().clone(),
-            _ => vortex_panic!(OutOfBounds: "ByteBoolArray buffer index {idx} out of bounds"),
+            _ => vortex_panic!("ByteBoolArray buffer index {idx} out of bounds"),
         }
     }
 
     fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
         match idx {
             0 => Some("values".to_string()),
-            _ => vortex_panic!(OutOfBounds: "ByteBoolArray buffer_name index {idx} out of bounds"),
+            _ => vortex_panic!("ByteBoolArray buffer_name index {idx} out of bounds"),
         }
     }
 
@@ -101,7 +101,7 @@ impl VTable for ByteBool {
         array: ArrayView<'_, Self>,
         buffers: &[BufferHandle],
     ) -> VortexResult<ArrayParts<Self>> {
-        vortex_ensure_eq!(buffers.len(), 1, InvalidArgument);
+        vortex_ensure_eq!(buffers.len(), 1);
         let data = ByteBoolData::new(buffers[0].clone());
         Ok(ArrayParts::new(
             self.clone(),
@@ -130,7 +130,7 @@ impl VTable for ByteBool {
     ) -> VortexResult<ArrayParts<Self>> {
         if !metadata.is_empty() {
             vortex_bail!(
-                InvalidArgument: "ByteBoolArray expects empty metadata, got {} bytes",
+                "ByteBoolArray expects empty metadata, got {} bytes",
                 metadata.len()
             );
         }
@@ -140,11 +140,11 @@ impl VTable for ByteBool {
             let validity = children.get(0, &Validity::DTYPE, len)?;
             Validity::Array(validity)
         } else {
-            vortex_bail!(MismatchedTypes: "Expected 0 or 1 child, got {}", children.len());
+            vortex_bail!("Expected 0 or 1 child, got {}", children.len());
         };
 
         if buffers.len() != 1 {
-            vortex_bail!(InvalidArgument: "Expected 1 buffer, got {}", buffers.len());
+            vortex_bail!("Expected 1 buffer, got {}", buffers.len());
         }
         let buffer = buffers[0].clone();
 
@@ -261,10 +261,10 @@ impl ByteBoolData {
         len: usize,
     ) -> VortexResult<()> {
         let expected_dtype = DType::Bool(validity.nullability());
-        vortex_ensure_eq!(dtype, &expected_dtype, MismatchedTypes);
-        vortex_ensure_eq!(buffer.len(), len, InvalidArgument);
+        vortex_ensure_eq!(dtype, &expected_dtype);
+        vortex_ensure_eq!(buffer.len(), len);
         if let Some(vlen) = validity.maybe_len() {
-            vortex_ensure_eq!(vlen, len, InvalidArgument);
+            vortex_ensure_eq!(vlen, len);
         }
         Ok(())
     }