[typechecking] Do not show constant values in type errors

src/expr/src/interpret.rs

@@ -1384,7 +1384,7 @@ mod tests {
             Ok(())
         }
 
-        proptest!(|(datum in mz_repr::arb_datum())| {
+        proptest!(|(datum in mz_repr::arb_datum(true))| {
             check(datum)?;
         });
 

src/expr/src/scalar.rs

@@ -2057,7 +2057,7 @@ impl MirScalarExpr {
         self.visit_pre(|e| {
             if let MirScalarExpr::Literal(row, _) = e {
                 if let Ok(row) = row {
-                    contains |= row.iter().any(|d| d == Datum::Dummy);
+                    contains |= row.iter().any(|d| d.contains_dummy());
                 }
             }
         });

src/repr/src/lib.rs

@@ -65,8 +65,8 @@ pub use crate::row::{
     datum_list_size, datum_size, datums_size, read_datum, row_size,
 };
 pub use crate::scalar::{
-    ArrayRustType, AsColumnType, Datum, DatumType, ExcludeNull, PropArray, PropDatum, PropDict,
-    PropList, ProtoScalarType, ReprScalarBaseType, ReprScalarType, SqlScalarBaseType,
+    ArrayRustType, AsColumnType, Datum, DatumKind, DatumType, ExcludeNull, PropArray, PropDatum,
+    PropDict, PropList, ProtoScalarType, ReprScalarBaseType, ReprScalarType, SqlScalarBaseType,
     SqlScalarType, arb_datum, arb_datum_for_column, arb_datum_for_scalar, arb_range_type,
 };
 pub use crate::timestamp::{Timestamp, TimestampManipulation};

src/repr/src/row.rs

@@ -312,7 +312,7 @@ impl Arbitrary for Row {
     type Strategy = BoxedStrategy<Row>;
 
     fn arbitrary_with(size: Self::Parameters) -> Self::Strategy {
-        prop::collection::vec(arb_datum(), size)
+        prop::collection::vec(arb_datum(true), size)
             .prop_map(|items| {
                 let mut row = Row::default();
                 let mut packer = row.packer();

src/repr/src/scalar.rs

@@ -71,7 +71,7 @@ use crate::{CatalogItemId, ColumnName, DatumList, DatumMap, Row, RowArena, SqlCo
 /// functions on `repr::row::RowPacker` prefixed with `push_`.
 ///
 #[derive(Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, EnumKind)]
-#[enum_kind(DatumKind)]
+#[enum_kind(DatumKind, derive(Hash))]
 pub enum Datum<'a> {
     /// The `false` boolean value.
     False,
@@ -1016,7 +1016,7 @@ impl<'a> Datum<'a> {
                     _ => false,
                 }
             } else {
-                // sql type checking
+                // general scalar repr type checking
                 match (datum, scalar_type) {
                     (Datum::Dummy, _) => false,
                     (Datum::Null, _) => false,
@@ -4386,6 +4386,26 @@ impl Datum<'_> {
     pub fn empty_map() -> Datum<'static> {
         EMPTY_MAP_ROW.unpack_first()
     }
+
+    pub fn contains_dummy(&self) -> bool {
+        match self {
+            Datum::Dummy => true,
+            Datum::List(list) => list.iter().any(|d| d.contains_dummy()),
+            Datum::Map(map) => map.iter().any(|(_, d)| d.contains_dummy()),
+            Datum::Array(array) => array.elements().iter().any(|d| d.contains_dummy()),
+            Datum::Range(range) => range.inner.map_or(false, |range| {
+                range
+                    .lower
+                    .bound
+                    .map_or(false, |d| d.datum().contains_dummy())
+                    || range
+                        .upper
+                        .bound
+                        .map_or(false, |d| d.datum().contains_dummy())
+            }),
+            _ => false,
+        }
+    }
 }
 
 /// A mirror type for [`Datum`] that can be proptest-generated.
@@ -4444,9 +4464,8 @@ impl Ord for PropDatum {
 }
 
 /// Generate an arbitrary [`PropDatum`].
-pub fn arb_datum() -> BoxedStrategy<PropDatum> {
-    let leaf = Union::new(vec![
-        Just(PropDatum::Dummy).boxed(),
+pub fn arb_datum(allow_dummy: bool) -> BoxedStrategy<PropDatum> {
+    let mut leaf_options = vec![
         any::<bool>().prop_map(PropDatum::Bool).boxed(),
         any::<i16>().prop_map(PropDatum::Int16).boxed(),
         any::<i32>().prop_map(PropDatum::Int32).boxed(),
@@ -4479,8 +4498,12 @@ pub fn arb_datum() -> BoxedStrategy<PropDatum> {
         arb_range(arb_range_data())
             .prop_map(PropDatum::Range)
             .boxed(),
-        Just(PropDatum::Dummy).boxed(),
-    ]);
+    ];
+
+    if allow_dummy {
+        leaf_options.push(Just(PropDatum::Dummy).boxed());
+    }
+    let leaf = Union::new(leaf_options);
 
     leaf.prop_recursive(3, 8, 16, |inner| {
         Union::new(vec![
@@ -5077,7 +5100,7 @@ mod tests {
         #![proptest_config(ProptestConfig::with_cases(10000))]
         #[mz_ore::test]
         #[cfg_attr(miri, ignore)]
-        fn sql_repr_types_agree_on_random_data(src in any::<SqlColumnType>(), datum in arb_datum()) {
+        fn sql_repr_types_agree_on_random_data(src in any::<SqlColumnType>(), datum in arb_datum(true)) {
             let tgt = ReprColumnType::from(&src);
             let datum = Datum::from(&datum);
 
@@ -5115,7 +5138,7 @@ mod tests {
     proptest! {
         #[mz_ore::test]
         #[cfg_attr(miri, ignore)] // unsupported operation: can't call foreign function `decContextDefault` on OS `linux`
-        fn array_packing_unpacks_correctly(array in arb_array(arb_datum())) {
+        fn array_packing_unpacks_correctly(array in arb_array(arb_datum(true))) {
             let PropArray(row, elts) = array;
             let datums: Vec<Datum<'_>> = elts.iter().map(|e| e.into()).collect();
             let unpacked_datums: Vec<Datum<'_>> = row.unpack_first().unwrap_array().elements().iter().collect();
@@ -5124,7 +5147,7 @@ mod tests {
 
         #[mz_ore::test]
         #[cfg_attr(miri, ignore)] // unsupported operation: can't call foreign function `decContextDefault` on OS `linux`
-        fn list_packing_unpacks_correctly(array in arb_list(arb_datum())) {
+        fn list_packing_unpacks_correctly(array in arb_list(arb_datum(true))) {
             let PropList(row, elts) = array;
             let datums: Vec<Datum<'_>> = elts.iter().map(|e| e.into()).collect();
             let unpacked_datums: Vec<Datum<'_>> = row.unpack_first().unwrap_list().iter().collect();
@@ -5133,7 +5156,7 @@ mod tests {
 
         #[mz_ore::test]
         #[cfg_attr(miri, ignore)] // too slow
-        fn dict_packing_unpacks_correctly(array in arb_dict(arb_datum())) {
+        fn dict_packing_unpacks_correctly(array in arb_dict(arb_datum(true))) {
             let PropDict(row, elts) = array;
             let datums: Vec<(&str, Datum<'_>)> = elts.iter().map(|(k, e)| (k.as_str(), e.into())).collect();
             let unpacked_datums: Vec<(&str, Datum<'_>)> = row.unpack_first().unwrap_map().iter().collect();
@@ -5142,7 +5165,7 @@ mod tests {
 
         #[mz_ore::test]
         #[cfg_attr(miri, ignore)] // too slow
-        fn row_packing_roundtrips_single_valued(prop_datums in prop::collection::vec(arb_datum(), 1..100)) {
+        fn row_packing_roundtrips_single_valued(prop_datums in prop::collection::vec(arb_datum(true), 1..100)) {
             let datums: Vec<Datum<'_>> = prop_datums.iter().map(|pd| pd.into()).collect();
             let row = Row::pack(&datums);
             let unpacked = row.unpack();