repr: catch spike up to current main (re-migrate drifted refs + tests)

Rebased the int-unification spike onto current main. The base spike commit
cherry-picked cleanly; this commit re-applies the mechanical follow-on work
against the new base and migrates the references that landed in main after the
original branch point (#37155, #37177, #36776 count-aware-aggregates, #36984):

- production: signed-sum fold + SumInt16/32 narrow (relation/func.rs), the
  generate_series-unoptimized literal (sql/func.rs), and the generate_series
  collapse (projection_pushdown.rs: ReprScalarType::Int64 -> Int, and the
  literal_i64 closure's int2/4/8 arms collapse to one Datum::Int arm).
- test/bench/doctest: ~292 Datum::IntN -> Datum::Int/UInt sites, plus the
  PropDatum::Int32 narrowings and an i64-typed literal in casts.rs.

Workspace builds clean under --all-targets.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: frankmcsherry

src/adapter/src/coord.rs

@@ -5435,7 +5435,7 @@ mod arrangement_sizes_pruner_tests {
         Row::pack_slice(&[
             Datum::String("r1"),
             Datum::String("u1"),
-            Datum::Int64(123),
+            Datum::Int(123),
             Datum::TimestampTz(dt.try_into().expect("fits in TimestampTz")),
         ])
     }

src/adapter/src/coord/peek.rs

@@ -1533,7 +1533,7 @@ mod tests {
         let lookup = FastPathPlan::PeekExisting(
             GlobalId::User(9),
             GlobalId::User(11),
-            Some(vec![Row::pack(Some(Datum::Int32(5)))]),
+            Some(vec![Row::pack(Some(Datum::Int(5)))]),
             MapFilterProject::new(3)
                 .filter(Some(
                     MirScalarExpr::column(0).call_unary(UnaryFunc::IsNull(IsNull)),

src/arrow-util/src/reader.rs

@@ -1040,8 +1040,8 @@ mod tests {
 
         packer.extend([
             Datum::True,
-            Datum::Int32(42),
-            Datum::UInt64(10000),
+            Datum::Int(42),
+            Datum::UInt(10000),
             Datum::Float32(OrderedFloat::from(-1.1f32)),
             Datum::String("hello world"),
             Datum::Bytes(b"1010101"),
@@ -1052,7 +1052,7 @@ mod tests {
                 serde_json::json!({"code": 200, "email": "space_monkey@materialize.com"}),
             )
             .expect("failed to pack JSON");
-        packer.push_list([Datum::UInt32(200), Datum::UInt32(300)]);
+        packer.push_list([Datum::UInt(200), Datum::UInt(300)]);
 
         let null_row = Row::pack(vec![Datum::Null; 9]);
 
@@ -1248,11 +1248,11 @@ mod tests {
             .push_range(Range::new(Some((
                 RangeLowerBound {
                     inclusive: true,
-                    bound: Some(Datum::Int32(1)),
+                    bound: Some(Datum::Int(1)),
                 },
                 RangeUpperBound {
                     inclusive: true,
-                    bound: Some(Datum::Int32(10)),
+                    bound: Some(Datum::Int(10)),
                 },
             ))))
             .unwrap();
@@ -1266,11 +1266,11 @@ mod tests {
             .push_range(Range::new(Some((
                 RangeLowerBound {
                     inclusive: false,
-                    bound: Some(Datum::Int32(5)),
+                    bound: Some(Datum::Int(5)),
                 },
                 RangeUpperBound {
                     inclusive: false,
-                    bound: Some(Datum::Int32(15)),
+                    bound: Some(Datum::Int(15)),
                 },
             ))))
             .unwrap();

src/catalog/src/expr_cache.rs

@@ -776,7 +776,7 @@ mod tests {
     /// That's sufficient for the expr cache tests, since the cache mostly treats expressions as
     /// opaque objects.
     fn gen_local_expressions() -> LocalExpressions {
-        let datum = Datum::UInt64(rand::random());
+        let datum = Datum::UInt(rand::random());
 
         LocalExpressions {
             local_mir: OptimizedMirRelationExpr(MirRelationExpr::constant(

src/compute/benches/columnar_merge_batcher_row.rs

@@ -87,7 +87,7 @@ fn make_row(key: u64) -> Row {
     let s = format!("k{:024x}", key);
     let mut row = Row::default();
     row.packer()
-        .extend([Datum::Int64(i64::reinterpret_cast(key)), Datum::String(&s)]);
+        .extend([Datum::Int(i64::reinterpret_cast(key)), Datum::String(&s)]);
     row
 }
 

src/compute/benches/columnar_merger_row.rs

@@ -61,7 +61,7 @@ const SIZES: &[(&str, usize)] = &[
 ];
 
 /// Encoded Row payload size estimate used to derive element counts from
-/// byte targets. Each row carries `Datum::Int64(key)` plus a 24-char
+/// byte targets. Each row carries `Datum::Int(key)` plus a 24-char
 /// hex-string suffix; the columnar encoding is not byte-exact but lands
 /// near this number for both representations.
 const ROW_PAYLOAD_BYTES: usize = 32;
@@ -78,7 +78,7 @@ fn make_row(key: u64) -> Row {
     let s = format!("k{:024x}", key);
     let mut row = Row::default();
     row.packer()
-        .extend([Datum::Int64(i64::reinterpret_cast(key)), Datum::String(&s)]);
+        .extend([Datum::Int(i64::reinterpret_cast(key)), Datum::String(&s)]);
     row
 }
 
@@ -162,7 +162,7 @@ fn configs(n: usize) -> [(&'static str, Vec<Tuple>, Vec<Tuple>); 3] {
                     // string-suffix invariant intact.
                     let datums: Vec<Datum> = d.iter().collect();
                     let key = match datums[0] {
-                        Datum::Int64(k) => u64::reinterpret_cast(k) + n_u64,
+                        Datum::Int(k) => u64::reinterpret_cast(k) + n_u64,
                         _ => unreachable!(),
                     };
                     (make_row(key), t, r)

src/compute/benches/correction.rs

@@ -165,7 +165,7 @@ fn make_correction(version: Version, metrics: &SinkMetrics) -> Corr {
 
 fn row(key: u64, value: u64) -> Row {
     let payload = format!("payload-{value:016}");
-    Row::pack_slice(&[Datum::UInt64(key), Datum::String(&payload)])
+    Row::pack_slice(&[Datum::UInt(key), Datum::String(&payload)])
 }
 
 /// Generate one batch of updates per distinct timestamp `0..num_ts`.

src/expr/benches/case_literal.rs

@@ -32,7 +32,7 @@ fn if_then_else(cond: MirScalarExpr, then: MirScalarExpr, els: MirScalarExpr) ->
 
 /// Build an i64 literal.
 fn lit_i64(v: i64) -> MirScalarExpr {
-    MirScalarExpr::literal_ok(Datum::Int64(v), ReprScalarType::Int)
+    MirScalarExpr::literal_ok(Datum::Int(v), ReprScalarType::Int)
 }
 
 /// Column reference.
@@ -56,7 +56,7 @@ fn build_case_literal(n: usize) -> MirScalarExpr {
     let scalar = build_if_chain(n);
     let mut relation = mz_expr::MirRelationExpr::Map {
         input: Box::new(mz_expr::MirRelationExpr::constant(
-            vec![vec![Datum::Int64(0)]],
+            vec![vec![Datum::Int(0)]],
             ReprRelationType::new(vec![ReprColumnType {
                 scalar_type: ReprScalarType::Int,
                 nullable: false,
@@ -95,7 +95,7 @@ fn bench_case_literal(c: &mut Criterion) {
         ];
 
         for &(scenario, input) in scenarios {
-            let datums = [Datum::Int64(input)];
+            let datums = [Datum::Int(input)];
 
             group.bench_function(format!("if_chain/{n}_arms/{scenario}"), |b| {
                 b.iter(|| black_box(&if_chain).eval(black_box(&datums), black_box(&arena)))

src/expr/benches/window_functions.rs

@@ -75,17 +75,17 @@ fn order_aggregate_datums_benchmark(c: &mut Criterion) {
         for _i in 0..scale {
             datums.push(temp_storage.make_datum(|packer| {
                 let orig_row_and_args = temp_storage.make_datum(|packer| {
-                    packer.push(Datum::Int32(3));
-                    packer.push(Datum::Int32(545577777));
-                    packer.push(Datum::Int32(123456789));
+                    packer.push(Datum::Int(3));
+                    packer.push(Datum::Int(545577777));
+                    packer.push(Datum::Int(123456789));
                     packer.push(Datum::String("aaaaaaaaaa"));
                 });
 
                 // An early version had non-random stuff here, but surprisingly this is much faster
                 // to sort, so it's not representative.
-                //let order_by_col_1 = Datum::Int32((scale - i) as i32);
+                //let order_by_col_1 = Datum::Int((scale - i) as i32);
                 // This is faster, probably because Int32 is easier to decode than a Timestamp.
-                //let order_by_col_1 = Datum::Int32(distr.sample(&mut rng));
+                //let order_by_col_1 = Datum::Int(distr.sample(&mut rng));
                 // So, we generate a random timestamp. Timestamps are a common thing to order by in
                 // window functions.
                 let order_by_col_1 = Datum::TimestampTz(

src/expr/src/interpret.rs

@@ -1719,7 +1719,7 @@ mod tests {
                         func: Eq.into(),
                         expr1: Box::new(MirScalarExpr::column(0)),
                         expr2: Box::new(MirScalarExpr::literal_ok(
-                            Datum::Int32(1727694505),
+                            Datum::Int(1727694505),
                             ReprScalarType::Int,
                         )),
                     },
@@ -1732,7 +1732,7 @@ mod tests {
         let relation = ReprRelationType::new(vec![ReprScalarType::Int.nullable(true)]);
         let arena = RowArena::new();
         let mut interpreter = ColumnSpecs::new(&relation, &arena);
-        interpreter.push_column(0, ResultSpec::value(Datum::Int32(-1294725158)));
+        interpreter.push_column(0, ResultSpec::value(Datum::Int(-1294725158)));
         let spec = interpreter.mfp_filter(&mfp);
         assert!(spec.range.may_fail());
     }
@@ -1758,7 +1758,7 @@ mod tests {
     #[mz_ore::test]
     fn test_eval_range() {
         // Example inspired by the tumbling windows temporal filter in the docs
-        let period_ms = MirScalarExpr::literal_ok(Datum::Int64(10), ReprScalarType::Int);
+        let period_ms = MirScalarExpr::literal_ok(Datum::Int(10), ReprScalarType::Int);
         let expr = MirScalarExpr::CallBinary {
             func: Gte.into(),
             expr1: Box::new(MirScalarExpr::CallUnmaterializable(