Require a kind on every vortex_err!, vortex_ensure! and vortex_panic!

A message with no leading `Kind:` still compiled and quietly became Other.
The previous commits tagged every vortex_err!/vortex_bail! site, but the
untagged form survived in 1133 other places: vortex_ensure! and
vortex_ensure_eq! pass their message straight to an untagged vortex_bail!, so
748 checks returned Other errors callers could see; 350 vortex_panic! calls
printed "Other error:"; and wrapper macros in vortex-jni and vortex-duckdb
forwarded bare messages the same way.

Every one now names its kind, chosen by reading the site:

  InvalidArgument  449   ValueError
  MismatchedTypes  272   TypeError
  AssertionFailed  182   AssertionError
  OutOfBounds       99   IndexError
  Serde             54   ValueError, as json.JSONDecodeError
  Overflow          32   OverflowError
  NotImplemented    31   NotImplementedError
  Io                 7   OSError
  Other              5   RuntimeError
  NotFound           2   KeyError

The split that mattered most for vortex_ensure!: a check on what the caller
passed in (a constructor's lengths, a builder's dtype) is InvalidArgument or
MismatchedTypes, a length mismatch is never a type error, and a check that a
kernel, rewrite or executor kept its own contract (a reduced array changing
dtype, a take producing the wrong length) is AssertionFailed. Checks made
while decoding metadata or a wire format are Serde.

The untagged arms are gone from vortex_err! and vortex_panic!. In their place
an arm raises a compile error naming the fix, e.g.

  vortex_err! needs a kind before its message, e.g.
  `vortex_err!(InvalidArgument: "negative length {}")`

vortex_ensure! reaches the same error through vortex_bail!. In vortex_panic!
the arm sits before the `$err:expr` arms, which a bare message would
otherwise match. The now-unused panic_fmt helper is removed. compile_fail
doctests on the three macros keep the untagged form from coming back.
vortex_ensure! without a message still produces AssertionFailed naming its
condition, as before.

duckdb_try! takes its message as `$msg:literal` rather than `$msg:expr`: a
fragment captured as expr cannot match vortex_err!'s literal matcher once
forwarded. Its message arms use Other, like its existing message-less arm,
since DuckDB's C API reports only a bare failure status.

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

encodings/alp/src/alp/array.rs

@@ -96,7 +96,7 @@ impl VTable for ALP {
     }
 
     fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
-        vortex_panic!("ALPArray buffer index {idx} out of bounds")
+        vortex_panic!(OutOfBounds: "ALPArray buffer index {idx} out of bounds")
     }
 
     fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
@@ -260,7 +260,7 @@ impl ALPData {
                 encoded.dtype(),
                 DType::Primitive(PType::I32 | PType::I64, _)
             ),
-            "ALP encoded ints have invalid DType {}",
+            MismatchedTypes: "ALP encoded ints have invalid DType {}",
             encoded.dtype(),
         );
 
@@ -269,15 +269,15 @@ impl ALPData {
         let Exponents { e, f } = exponents;
         match encoded.dtype().as_ptype() {
             PType::I32 => {
-                vortex_ensure!(exponents.e <= f32::MAX_EXPONENT, "e out of bounds: {e}");
-                vortex_ensure!(exponents.f <= f32::MAX_EXPONENT, "f out of bounds: {f}");
+                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}");
                 if let Some(patches) = patches {
                     Self::validate_patches::<f32>(patches, encoded)?;
                 }
             }
             PType::I64 => {
-                vortex_ensure!(e <= f64::MAX_EXPONENT, "e out of bounds: {e}");
-                vortex_ensure!(f <= f64::MAX_EXPONENT, "f out of bounds: {f}");
+                vortex_ensure!(e <= f64::MAX_EXPONENT, InvalidArgument: "e out of bounds: {e}");
+                vortex_ensure!(f <= f64::MAX_EXPONENT, InvalidArgument: "f out of bounds: {f}");
 
                 if let Some(patches) = patches {
                     Self::validate_patches::<f64>(patches, encoded)?;
@@ -290,7 +290,7 @@ impl ALPData {
         if let Some(patches) = patches {
             vortex_ensure!(
                 patches.array_len() == encoded.len(),
-                "patches array_len != encoded len: {} != {}",
+                InvalidArgument: "patches array_len != encoded len: {} != {}",
                 patches.array_len(),
                 encoded.len()
             );
@@ -322,15 +322,15 @@ impl ALPData {
     ) -> VortexResult<()> {
         vortex_ensure!(
             patches.array_len() == encoded.len(),
-            "patches array_len != encoded len: {} != {}",
+            InvalidArgument: "patches array_len != encoded len: {} != {}",
             patches.array_len(),
             encoded.len()
         );
 
         let expected_type = DType::Primitive(T::PTYPE, encoded.dtype().nullability());
         vortex_ensure!(
             patches.dtype() == &expected_type,
-            "Expected patches type {expected_type}, actual {}",
+            MismatchedTypes: "Expected patches type {expected_type}, actual {}",
             patches.dtype(),
         );
 
@@ -447,12 +447,12 @@ fn validate_parts(
     ALPData::validate_components(encoded, exponents, patches.as_ref())?;
     vortex_ensure!(
         encoded.len() == len,
-        "ALP encoded len {} != outer len {len}",
+        InvalidArgument: "ALP encoded len {} != outer len {len}",
         encoded.len(),
     );
     vortex_ensure!(
         &logical_dtype == dtype,
-        "ALP dtype {} does not match encoded logical dtype {}",
+        MismatchedTypes: "ALP dtype {} does not match encoded logical dtype {}",
         dtype,
         logical_dtype,
     );

encodings/alp/src/alp/compress.rs

@@ -39,7 +39,7 @@ macro_rules! match_each_alp_float_ptype {
                 type $enc = f64;
                 $body
             }
-            _ => vortex_panic!("ALP can only encode f32 and f64, got {}", ptype),
+            _ => vortex_panic!(MismatchedTypes: "ALP can only encode f32 and f64, got {}", ptype),
         }
     }};
 }

encodings/alp/src/alp/plugin.rs

@@ -54,7 +54,7 @@ impl ArrayPlugin for ALPPatchedPlugin {
     ) -> VortexResult<ArrayRef> {
         vortex_ensure!(
             parts.serialized_id == self.id(),
-            "ALP plugin does not recognize serialized ID {}",
+            Serde: "ALP plugin does not recognize serialized ID {}",
             parts.serialized_id,
         );
         let alp_array = Array::<ALP>::try_from_parts(ArrayVTable::deserialize(

encodings/alp/src/alp_rd/array.rs

@@ -121,7 +121,7 @@ impl VTable for ALPRD {
     }
 
     fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
-        vortex_panic!("ALPRDArray buffer index {idx} out of bounds")
+        vortex_panic!(OutOfBounds: "ALPRDArray buffer index {idx} out of bounds")
     }
 
     fn buffer_name(_array: ArrayView<'_, Self>, _idx: usize) -> Option<String> {
@@ -478,12 +478,12 @@ fn validate_parts(
 
     vortex_ensure!(
         left_parts.len() == len,
-        "left_parts len {} != outer len {len}",
+        InvalidArgument: "left_parts len {} != outer len {len}",
         left_parts.len(),
     );
     vortex_ensure!(
         right_parts.len() == len,
-        "right_parts len {} != outer len {len}",
+        InvalidArgument: "right_parts len {} != outer len {len}",
         right_parts.len(),
     );
 
@@ -505,15 +505,15 @@ fn validate_parts(
     };
     vortex_ensure!(
         right_parts.dtype() == &expected_right_parts_dtype,
-        "right_parts dtype {} does not match expected {}",
+        MismatchedTypes: "right_parts dtype {} does not match expected {}",
         right_parts.dtype(),
         expected_right_parts_dtype,
     );
 
     if let Some(patches) = left_parts_patches {
         vortex_ensure!(
             patches.array_len() == len,
-            "patches array_len {} != outer len {len}",
+            InvalidArgument: "patches array_len {} != outer len {len}",
             patches.array_len(),
         );
         // Left-parts exceptions are always all-valid and are stored as the non-nullable left-parts
@@ -523,7 +523,7 @@ fn validate_parts(
         let expected = left_parts.dtype().as_nonnullable();
         vortex_ensure!(
             patches.dtype() == &expected,
-            "patches dtype {} must be the non-nullable left_parts dtype {}",
+            MismatchedTypes: "patches dtype {} must be the non-nullable left_parts dtype {}",
             patches.dtype(),
             expected,
         );

encodings/alp/src/alp_rd/mod.rs

@@ -146,7 +146,7 @@ where
     T::UINT: NativePType,
 {
     if left_parts.len() != right_parts.len() {
-        vortex_panic!("alp_rd_decode: left_parts.len != right_parts.len");
+        vortex_panic!(AssertionFailed: "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!("ByteBoolArray buffer index {idx} out of bounds"),
+            _ => vortex_panic!(OutOfBounds: "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!("ByteBoolArray buffer_name index {idx} out of bounds"),
+            _ => vortex_panic!(OutOfBounds: "ByteBoolArray buffer_name index {idx} out of bounds"),
         }
     }
 
@@ -103,7 +103,7 @@ impl VTable for ByteBool {
     ) -> VortexResult<ArrayParts<Self>> {
         vortex_ensure!(
             buffers.len() == 1,
-            "Expected 1 buffer, got {}",
+            InvalidArgument: "Expected 1 buffer, got {}",
             buffers.len()
         );
         let data = ByteBoolData::new(buffers[0].clone());
@@ -262,15 +262,15 @@ impl ByteBoolData {
         let expected_dtype = DType::Bool(validity.nullability());
         vortex_ensure!(
             dtype == &expected_dtype,
-            "expected dtype {expected_dtype}, got {dtype}"
+            MismatchedTypes: "expected dtype {expected_dtype}, got {dtype}"
         );
         vortex_ensure!(
             buffer.len() == len,
-            "expected len {len}, got {}",
+            InvalidArgument: "expected len {len}, got {}",
             buffer.len()
         );
         if let Some(vlen) = validity.maybe_len() {
-            vortex_ensure!(vlen == len, "expected validity len {len}, got {vlen}");
+            vortex_ensure!(vlen == len, InvalidArgument: "expected validity len {len}, got {vlen}");
         }
         Ok(())
     }

encodings/datetime-parts/src/array.rs

@@ -115,11 +115,11 @@ impl VTable for DateTimeParts {
     }
 
     fn buffer(_array: ArrayView<'_, Self>, idx: usize) -> BufferHandle {
-        vortex_panic!("DateTimePartsArray buffer index {idx} out of bounds")
+        vortex_panic!(OutOfBounds: "DateTimePartsArray buffer index {idx} out of bounds")
     }
 
     fn buffer_name(_array: ArrayView<'_, Self>, idx: usize) -> Option<String> {
-        vortex_panic!("DateTimePartsArray buffer_name index {idx} out of bounds")
+        vortex_panic!(OutOfBounds: "DateTimePartsArray buffer_name index {idx} out of bounds")
     }
 
     fn with_buffers(
@@ -309,7 +309,7 @@ impl DateTimePartsData {
         subseconds: &ArrayRef,
         len: usize,
     ) -> VortexResult<()> {
-        vortex_ensure!(days.len() == len, "expected len {len}, got {}", days.len());
+        vortex_ensure!(days.len() == len, InvalidArgument: "expected len {len}, got {}", days.len());
 
         if !days.dtype().is_int() || (dtype.is_nullable() != days.dtype().is_nullable()) {
             vortex_bail!(

encodings/datetime-parts/src/compute/take.rs

@@ -49,16 +49,16 @@ fn take_datetime_parts(
     // If they became nullable due to nullable indices, we need to fill nulls.
     // But first, we need to check that the types are consistent.
     if !taken_days.dtype().is_nullable() {
-        vortex_panic!("Mismatched types: days is not nullable, seconds is nullable");
+        vortex_panic!(MismatchedTypes: "Mismatched types: days is not nullable, seconds is nullable");
     }
     if !taken_seconds.dtype().is_nullable() {
-        vortex_panic!("Mismatched types: seconds is not nullable, days is nullable");
+        vortex_panic!(MismatchedTypes: "Mismatched types: seconds is not nullable, days is nullable");
     }
     if !taken_subseconds.dtype().is_nullable() {
-        vortex_panic!("Mismatched types: subseconds is not nullable, days & seconds are nullable");
+        vortex_panic!(MismatchedTypes: "Mismatched types: subseconds is not nullable, days & seconds are nullable");
     }
     if !indices.dtype().is_nullable() {
-        vortex_panic!("Mismatched types: indices are not nullable, days & seconds are nullable");
+        vortex_panic!(MismatchedTypes: "Mismatched types: indices are not nullable, days & seconds are nullable");
     }
 
     let seconds_fill = array

encodings/datetime-parts/src/ops.rs

@@ -26,7 +26,7 @@ impl OperationsVTable<DateTimeParts> for DateTimeParts {
     ) -> VortexResult<Scalar> {
         let DType::Extension(ext) = array.dtype().clone() else {
             vortex_panic!(
-                "DateTimePartsArray must have extension dtype, found {}",
+                MismatchedTypes: "DateTimePartsArray must have extension dtype, found {}",
                 array.dtype()
             );
         };

encodings/datetime-parts/src/timestamp.rs

@@ -71,7 +71,7 @@ pub fn combine(ts_parts: TimestampParts, time_unit: TimeUnit) -> i64 {
         TimeUnit::Microseconds => 1_000_000,
         TimeUnit::Milliseconds => 1_000,
         TimeUnit::Seconds => 1,
-        TimeUnit::Days => vortex_panic!("Cannot handle day-level data"),
+        TimeUnit::Days => vortex_panic!(NotImplemented: "Cannot handle day-level data"),
     };
 
     ts_parts.days as i64 * SECONDS_PER_DAY * divisor