Skip codegen of unreachable int to decimal carrier arms (#10735)

The scaled-down integer to decimal cast selects its carrier as
`max(carrier(S), T)`. The source type `S` and the target type `T` fix
the carrier, but `match_each_decimal_value_type!` compiled the kernel
for all six decimal widths in each of the 48 `(S, T)` pairs. An `if
const` condition now removes the five arms that cannot match before code
generation. The arm that runs is the same as before.

`primitive_decimal_carrier_type` becomes a `const fn` so that the
condition can use it.

| | before | after |
|---|---|---|
| `vortex-array` release `__text` (macOS arm64) | 14,012,988 B |
13,697,852 B (-315 KB) |
| `vortex-array` LLVM IR lines | 5,405,422 | 5,200,767 |

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

Author: robert3005

vortex-array/src/arrays/primitive/compute/cast.rs

@@ -312,17 +312,40 @@ where
     // signed carrier that can represent both the source and target.
     let carrier_type = primitive_decimal_carrier_type(array.ptype()).max(T::DECIMAL_TYPE);
     match_each_decimal_value_type!(carrier_type, |W| {
-        let scale_factor = decimal_scale_factor::<W>(decimal_dtype.scale())?;
-        cast_integer_values_to_decimal_buffer(values, decimal_dtype, valid_values, |value| {
-            let value = <W as BigCast>::from(value)?;
-            let quotient = value / scale_factor;
-            let value = (quotient * scale_factor == value).then_some(quotient)?;
-            let value = <T as BigCast>::from(value)?;
-            decimal_value_fits_precision(value, decimal_dtype).then_some(value)
-        })
+        // `S` and `T` fix the carrier, so only one arm can match. The const condition lets the
+        // compiler skip codegen of the kernel for the other arms.
+        if const { is_scaled_down_carrier::<S, T, W>() } {
+            let scale_factor = decimal_scale_factor::<W>(decimal_dtype.scale())?;
+            cast_integer_values_to_decimal_buffer(values, decimal_dtype, valid_values, |value| {
+                let value = <W as BigCast>::from(value)?;
+                let quotient = value / scale_factor;
+                let value = (quotient * scale_factor == value).then_some(quotient)?;
+                let value = <T as BigCast>::from(value)?;
+                decimal_value_fits_precision(value, decimal_dtype).then_some(value)
+            })
+        } else {
+            unreachable!(
+                "{carrier_type} is not the scaled-down carrier for {}",
+                S::PTYPE
+            )
+        }
     })
 }
 
+/// Whether `W` is the carrier that a scaled-down cast from `S` to `T` selects.
+const fn is_scaled_down_carrier<S, T, W>() -> bool
+where
+    S: NativePType,
+    T: NativeDecimalType,
+    W: NativeDecimalType,
+{
+    let carrier = primitive_decimal_carrier_type(S::PTYPE) as u8;
+    let target = T::DECIMAL_TYPE as u8;
+    let selected = if carrier > target { carrier } else { target };
+
+    W::DECIMAL_TYPE as u8 == selected
+}
+
 fn cast_integer_values_to_decimal_buffer<S, T>(
     values: &[S],
     decimal_dtype: DecimalDType,
@@ -352,15 +375,19 @@ fn signed_primitive_decimal_type(ptype: PType) -> Option<DecimalType> {
 }
 
 /// The smallest signed decimal physical type that represents every `ptype` value.
-fn primitive_decimal_carrier_type(ptype: PType) -> DecimalType {
+#[expect(
+    clippy::panic,
+    reason = "`unreachable!` with a message is not available in a const fn"
+)]
+const fn primitive_decimal_carrier_type(ptype: PType) -> DecimalType {
     match ptype {
         PType::I8 => DecimalType::I8,
         PType::U8 | PType::I16 => DecimalType::I16,
         PType::U16 | PType::I32 => DecimalType::I32,
         PType::U32 | PType::I64 => DecimalType::I64,
         PType::U64 => DecimalType::I128,
         PType::F16 | PType::F32 | PType::F64 => {
-            unreachable!("floating primitives are rejected before selecting a decimal carrier")
+            panic!("floating primitives are rejected before selecting a decimal carrier")
         }
     }
 }
@@ -687,6 +714,7 @@ mod test {
     use crate::dtype::PType;
     use crate::dtype::i256;
     use crate::expr::stats::Stat;
+    use crate::match_each_decimal_value_type;
     use crate::validity::Validity;
 
     static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
@@ -1013,6 +1041,39 @@ mod test {
         Ok(())
     }
 
+    #[rstest]
+    fn cast_integer_to_negative_scale_decimal_every_width(
+        #[values(
+            PType::U8, PType::U16, PType::U32, PType::U64, PType::I8, PType::I16, PType::I32,
+            PType::I64
+        )]
+        ptype: PType,
+        #[values(2, 4, 9, 18, 38, 76)] precision: u8,
+    ) -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+        let decimal_dtype = DecimalDType::new(precision, -1);
+        let casted = PrimitiveArray::from_iter([100u8, 30])
+            .into_array()
+            .cast(DType::Primitive(ptype, Nullability::NonNullable))?
+            .cast(DType::Decimal(decimal_dtype, Nullability::NonNullable))?
+            .execute::<DecimalArray>(&mut ctx)?;
+
+        assert_eq!(
+            casted.values_type(),
+            DecimalType::smallest_decimal_value_type(&decimal_dtype)
+        );
+        match_each_decimal_value_type!(casted.values_type(), |T| {
+            let expected = [10i8, 3].map(<T as crate::dtype::BigCast>::from);
+            let actual = casted
+                .buffer::<T>()
+                .iter()
+                .map(|&value| Some(value))
+                .collect::<Vec<_>>();
+            assert_eq!(actual, expected);
+        });
+        Ok(())
+    }
+
     #[test]
     fn cast_zero_to_large_negative_scale_decimal() -> VortexResult<()> {
         let mut ctx = SESSION.create_execution_ctx();