shape/

display.rs

use std::fmt::Debug;
use std::fmt::Display;
use std::fmt::Write as _;

use super::helpers::quote_string;
use super::Shape;
use super::ShapeCase;
use crate::helpers::quote_non_identifier;
use crate::name::Name;

const UNIT_OF_INDENTATION: &str = "  ";
const WRAP_COLUMN: usize = 60;

/// Printed by [`Shape::pretty_print_bounded`] in place of whatever it leaves
/// out. Deliberately not `...`, which already marks an array's tail or an
/// object's rest.
const ELIDED: &str = "…";

/// Limits for [`Shape::pretty_print_bounded`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PrintLimits {
    /// How many levels of nested arrays and objects to print. Anything deeper
    /// prints as `…`. A union or intersection counts as a level only when two
    /// or more of the members it prints are themselves arrays, objects, unions
    /// or intersections: a nullable object (`One<{ ... }, null>`) costs the
    /// same as the object, while a choice between several objects costs a
    /// level, like the objects it multiplies.
    pub max_depth: usize,
    /// How many elements, fields or members of any one shape to print, after
    /// which a single `…` stands for the rest. Object fields and union or
    /// intersection members carrying their own errors are kept ahead of the
    /// cutoff. Array elements are positional, so they are never reordered.
    pub max_width: usize,
}

impl Default for PrintLimits {
    fn default() -> Self {
        Self {
            max_depth: 3,
            max_width: 8,
        }
    }
}

impl Shape {
    /// Returns a string representation of the [`Shape`], including any attached
    /// errors as `(err "message")` suffix.
    ///
    /// Please note: this display format does not imply an input syntax or
    /// parser for the shape language. To create new [`Shape`] elements, use the
    /// various `Shape::*` helper functions.
    #[must_use]
    pub fn pretty_print(&self) -> String {
        self.pretty_print_at_depth(0)
    }

    fn pretty_print_at_depth(&self, depth: usize) -> String {
        let pretty_shape =
            self.pretty_print_recursive(depth, usize::MAX, Shape::pretty_print_at_depth);
        self.append_error_suffix(pretty_shape)
    }

    /// Like [`Shape::pretty_print`], but prints at most `limits.max_depth`
    /// levels of nesting and `limits.max_width` children of any one shape,
    /// printing `…` for whatever it leaves out.
    ///
    /// Use this wherever a shape of unknown size is printed for a person to
    /// read, such as in an error message. A shape can share its subtrees, so
    /// its full printed form can be exponentially larger than the shape is in
    /// memory. This stops at the limits rather than printing everything and
    /// truncating, so its cost is bounded too.
    #[must_use]
    pub fn pretty_print_bounded(&self, limits: PrintLimits) -> String {
        self.pretty_print_bounded_at_depth(0, limits.max_depth, limits.max_width)
    }

    fn pretty_print_bounded_at_depth(
        &self,
        depth: usize,
        remaining_depth: usize,
        max_width: usize,
    ) -> String {
        let child_remaining_depth = match self.case() {
            ShapeCase::Array { .. } | ShapeCase::Object { .. } => {
                if remaining_depth == 0 {
                    // The shape's own errors survive its elision. They are
                    // usually the point of the message, and reading them
                    // costs nothing more than the shape itself did.
                    return self.append_error_suffix(ELIDED.to_string());
                }
                remaining_depth - 1
            }
            // A union or intersection that merely wraps one composite shape
            // (`One<{ ... }, null>`) is free. One that chooses between several
            // composite shapes multiplies the output the same way a level of
            // fields does, so it is charged like one; otherwise the bound is
            // (max_width * members)^max_depth, which is 2 MB at the defaults
            // for eight-way unions, not the 8^3 leaves the limits suggest.
            // The union itself still prints, so `One<…, null>` keeps saying
            // what was there. Only the members the width lets through count,
            // since the output grows only through printed members.
            ShapeCase::One(members) if has_several_composite_members(members.iter(), max_width) => {
                remaining_depth.saturating_sub(1)
            }
            ShapeCase::All(members) if has_several_composite_members(members.iter(), max_width) => {
                remaining_depth.saturating_sub(1)
            }
            _ => remaining_depth,
        };
        let pretty_shape = self.pretty_print_recursive(depth, max_width, |child, child_depth| {
            child.pretty_print_bounded_at_depth(child_depth, child_remaining_depth, max_width)
        });
        self.append_error_suffix(pretty_shape)
    }

    /// Returns a string representation of the [`Shape`] without any error
    /// annotations. This is the most concise representation.
    #[must_use]
    pub fn pretty_print_without_errors(&self) -> String {
        self.pretty_print_without_errors_at_depth(0)
    }

    fn pretty_print_without_errors_at_depth(&self, depth: usize) -> String {
        self.pretty_print_recursive(
            depth,
            usize::MAX,
            Shape::pretty_print_without_errors_at_depth,
        )
    }

    /// Returns a string representation of the [`Shape`] with [`Name`] metadata
    /// included as `<shape> (aka <name1>, <name2>)` and error metadata as
    /// `(err "message")`. Errors are shown first, then names.
    #[must_use]
    pub fn pretty_print_with_names(&self) -> String {
        self.pretty_print_with_names_at_depth(0)
    }

    fn pretty_print_with_names_at_depth(&self, depth: usize) -> String {
        let pretty_shape =
            self.pretty_print_recursive(depth, usize::MAX, Shape::pretty_print_with_names_at_depth);

        let mut result = pretty_shape;

        // Append errors first
        result = self.append_error_suffix(result);

        // Then append names
        if self.names().count() > 0 {
            let joined = self
                .names()
                .map(Name::to_string)
                .collect::<Vec<_>>()
                .join(", ");
            // Since the (aka ...) annotation trails multiline array and object
            // shapes, it often fits neatly into the otherwise mostly empty line
            // just after the closing ] or }.
            result = format!("{result} (aka {joined})");
        }

        result
    }

    /// Helper to append `(err "msg1", "msg2")` suffix if shape has its own errors.
    fn append_error_suffix(&self, pretty_shape: String) -> String {
        let error_messages: Vec<_> = self
            .own_errors()
            .map(|e| quote_string(&e.message))
            .collect();
        if error_messages.is_empty() {
            return pretty_shape;
        }
        format!("{pretty_shape} (err {})", error_messages.join(", "))
    }

    #[allow(clippy::too_many_lines)]
    fn pretty_print_recursive(
        &self,
        depth: usize,
        max_width: usize,
        print: impl Fn(&Shape, usize) -> String,
    ) -> String {
        fn print_flexible_wrapper(
            prefix: &str,
            pretty_children: impl IntoIterator<Item = String>,
            suffix: &str,
            depth: usize,
        ) -> String {
            let pretty_children = pretty_children.into_iter().collect::<Vec<_>>();

            // We may want to print the one-line version with some padding
            // inside the prefix/suffix, but we don't want that for the
            // multiline version, so we strip any padding before proceeding.
            let trimmed_prefix = prefix.trim();
            let trimmed_suffix = suffix.trim();

            if pretty_children.is_empty() {
                // If prefix was "{ " and suffix was " }", this prints "{}"
                // without the spaces when pretty_children is empty.
                return format!("{trimmed_prefix}{trimmed_suffix}");
            }

            if let (1, Some(only)) = (pretty_children.len(), pretty_children.first()) {
                // If there is only one child, always print it without
                // leading/trailing line breaks (though `prefix` and `suffix`
                // may include padding spaces, and `only` may print with its own
                // internal line breaks).
                return format!("{prefix}{only}{suffix}");
            }

            if pretty_children
                .iter()
                .all(|pretty| pretty.lines().count() <= 1)
            {
                // If all the children are single-line, and they fit within
                // WRAP_COLUMN columns, we may be able to print them all on one
                // line. Note we are using the untrimmed prefix and suffix,
                // since this is a place where padding spaces may be desired.
                //
                // By corollary, if the shape has any multiline children, the
                // whole shape needs to be printed with line breaks. We never
                // want to print mixed inline/multiline expressions, as in
                //
                //   [a, {
                //     blah: 1
                //   }, b, c, {
                //     whatever: true
                //   }]
                //
                // A human might be able to make this style readable, but
                // machine formatters that allow this hybrid line style tend to
                // produce unreadable monstrosities.
                let one_line = format!("{prefix}{}{suffix}", pretty_children.join(", "));
                if one_line.len() <= WRAP_COLUMN {
                    return one_line;
                }
                // If trying to print all the children on one line would exceed
                // WRAP_COLUMN columns, proceed to multi-line printing...
            }

            let mut result = format!("{trimmed_prefix}\n");
            let child_indent = UNIT_OF_INDENTATION.repeat(depth + 1);

            for pretty in &pretty_children {
                let _ = writeln!(result, "{child_indent}{pretty},");
            }

            let suffix_indent = UNIT_OF_INDENTATION.repeat(depth);
            let _ = write!(result, "{suffix_indent}{trimmed_suffix}");

            result
        }

        match self.case() {
            ShapeCase::Bool(Some(b)) => b.to_string(),
            ShapeCase::Bool(None) => "Bool".to_string(),
            ShapeCase::String(Some(s)) => quote_string(s.as_str()),
            ShapeCase::String(None) => "String".to_string(),
            ShapeCase::Int(Some(i)) => i.to_string(),
            ShapeCase::Int(None) => "Int".to_string(),
            ShapeCase::Float => "Float".to_string(),
            ShapeCase::Null => "null".to_string(), // No typo: JSON null is lowercase.

            ShapeCase::Unknown => "Unknown".to_string(),

            // There may be some argument for using lower-case "none" here,
            // since None is not a reserved/built-in GraphQL type name like
            // Bool, String, Int, and Float are, so someone could define a
            // custom GraphQL None type that would collide with this Shape name.
            ShapeCase::None => "None".to_string(),

            ShapeCase::Array { prefix, tail } => {
                let mut pretty_prefix = prefix
                    .iter()
                    .take(max_width)
                    .map(|shape| print(shape, depth + 1))
                    .collect::<Vec<_>>();
                if prefix.len() > max_width {
                    pretty_prefix.push(ELIDED.to_string());
                }

                if !tail.is_none() {
                    // Condense the tail indicator so the structural prefix
                    // stays readable. `...` alone marks the common
                    // open-`Unknown` tail; otherwise prepend `...` to the
                    // tail's own pretty-print, which already carries any
                    // errors / names the tail shape has. A prefix-free open
                    // array (formerly the canonical `List<S>` form) thus
                    // renders as `[...S]`, or just `[...]` when S is Unknown.
                    let pretty_tail_inner = print(tail, depth + 1);
                    let rest_marker = if pretty_tail_inner == "Unknown" {
                        "...".to_string()
                    } else {
                        format!("...{pretty_tail_inner}")
                    };
                    pretty_prefix.push(rest_marker);
                }

                print_flexible_wrapper("[", pretty_prefix, "]", depth)
            }

            ShapeCase::Object { fields, rest } => {
                // Sort before printing, so that a `max_width` limit keeps the
                // same fields whatever their insertion order, and fields past
                // the limit are never printed at all.
                let mut sorted_properties = fields.iter().collect::<Vec<_>>();
                sorted_properties.sort_by_key(|(key, _)| key.as_str());

                if fields.len() > max_width {
                    // Fields carrying their own errors are kept ahead of the
                    // cutoff, since those errors are usually what the reader
                    // needs, and the kept fields then go back into key order.
                    // `has_own_errors` is O(1); the recursive `has_errors`
                    // would visit the subtrees the limits exist to skip.
                    let (with_errors, without_errors): (Vec<_>, Vec<_>) = sorted_properties
                        .into_iter()
                        .partition(|(_, value)| value.has_own_errors());
                    sorted_properties = with_errors
                        .into_iter()
                        .chain(without_errors)
                        .take(max_width)
                        .collect();
                    sorted_properties.sort_by_key(|(key, _)| key.as_str());
                }

                let mut pretty_properties = sorted_properties
                    .into_iter()
                    .map(|(key, value)| {
                        format!("{}: {}", quote_non_identifier(key), print(value, depth + 1))
                    })
                    .collect::<Vec<_>>();
                if fields.len() > max_width {
                    pretty_properties.push(ELIDED.to_string());
                }

                // Named fields get padded braces (`{ a: Int }`); a bare
                // rest-only object prints tight (`{...S}`), so remember
                // whether any real fields were present before we push the
                // rest marker below.
                let has_fields = !pretty_properties.is_empty();

                if !rest.is_none() {
                    // Condense the rest indicator so the structural fields
                    // stay readable. `...` alone marks the common
                    // open-`Unknown` rest; otherwise prepend `...` to the
                    // rest's own pretty-print, which already carries any
                    // errors / names the rest shape has. A field-free open
                    // object (formerly the canonical `Dict<S>` form) thus
                    // renders as `{...S}`, or just `{...}` when S is Unknown.
                    let pretty_rest_inner = print(rest, depth + 1);
                    let rest_marker = if pretty_rest_inner == "Unknown" {
                        "...".to_string()
                    } else {
                        format!("...{pretty_rest_inner}")
                    };
                    pretty_properties.push(rest_marker);
                }

                // When there are named fields and the object prints on a
                // single line, the opening and closing braces carry this
                // extra space of padding. If the object is broken onto
                // multiple lines, `print_flexible_wrapper` trims it. A bare
                // rest-only object (`{...S}`) uses tight braces with no
                // padding.
                let (prefix, suffix) = if has_fields { ("{ ", " }") } else { ("{", "}") };

                print_flexible_wrapper(prefix, pretty_properties, suffix, depth)
            }

            ShapeCase::One(shapes) => {
                let pretty = print_flexible_wrapper(
                    "One<",
                    print_members(shapes.iter(), max_width, |child_shape| {
                        print(child_shape, depth + 1)
                    }),
                    ">",
                    depth,
                );

                // The empty `One<>` union represents an unsatisfiable shape
                // like TypeScript's `never` type, so that's how we print it.
                if pretty == "One<>" {
                    "Never".to_string()
                } else {
                    pretty
                }
            }

            ShapeCase::All(shapes) => print_flexible_wrapper(
                "All<",
                print_members(shapes.iter(), max_width, |child_shape| {
                    print(child_shape, depth + 1)
                }),
                ">",
                depth,
            ),

            ShapeCase::Name(name, _weak) => name.to_string(),
        }
    }
}

/// Print the members that `max_width` lets through (see [`kept_members`]),
/// then one [`ELIDED`] marker if any were left out.
fn print_members<'a>(
    members: impl Iterator<Item = &'a Shape>,
    max_width: usize,
    print: impl Fn(&Shape) -> String,
) -> Vec<String> {
    let (kept, elided) = kept_members(members, max_width);
    let mut pretty = kept.into_iter().map(print).collect::<Vec<_>>();
    if elided {
        pretty.push(ELIDED.to_string());
    }
    // Members are a set, so every member elided by depth collapses into one
    // bare marker: `One<…, null>` rather than `One<…, null, …>`. A marker
    // carrying errors (`… (err "…")`) is not bare, and stays.
    let mut seen_bare_marker = false;
    pretty.retain(|member| {
        if member != ELIDED {
            return true;
        }
        let first = !seen_bare_marker;
        seen_bare_marker = true;
        first
    });
    pretty
}

/// The members of a union or intersection that `max_width` lets through, in
/// their original order, and whether any were left out. Members carrying
/// their own errors are kept ahead of the cutoff, for the same reason object
/// fields are: those errors are usually what the reader needs. Only
/// `has_own_errors` (O(1)) is consulted, so the cost bound holds.
fn kept_members<'a>(
    members: impl Iterator<Item = &'a Shape>,
    max_width: usize,
) -> (Vec<&'a Shape>, bool) {
    let members = members.collect::<Vec<_>>();
    if members.len() <= max_width {
        return (members, false);
    }
    let (with_errors, without_errors): (Vec<usize>, Vec<usize>) =
        (0..members.len()).partition(|&index| members[index].has_own_errors());
    let mut kept = with_errors
        .into_iter()
        .chain(without_errors)
        .take(max_width)
        .collect::<Vec<_>>();
    kept.sort_unstable();
    (kept.into_iter().map(|index| members[index]).collect(), true)
}

/// Whether two or more of the members that `max_width` lets through are
/// arrays, objects, unions or intersections. See [`PrintLimits::max_depth`].
fn has_several_composite_members<'a>(
    members: impl Iterator<Item = &'a Shape>,
    max_width: usize,
) -> bool {
    kept_members(members, max_width)
        .0
        .into_iter()
        .filter(|member| {
            matches!(
                member.case(),
                ShapeCase::Array { .. }
                    | ShapeCase::Object { .. }
                    | ShapeCase::One(_)
                    | ShapeCase::All(_)
            )
        })
        .nth(1)
        .is_some()
}

impl Debug for Shape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Shape({})", self.pretty_print_with_names())
    }
}

impl Display for Shape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.pretty_print())
    }
}

#[cfg(test)]
mod bounded_tests {
    use indexmap::IndexMap;

    use super::PrintLimits;
    use crate::Shape;

    fn record(fields: impl IntoIterator<Item = (impl Into<String>, Shape)>) -> Shape {
        Shape::closed_record(
            fields
                .into_iter()
                .map(|(key, value)| (key.into(), value))
                .collect::<IndexMap<_, _>>(),
            [],
        )
    }

    fn limits(max_depth: usize, max_width: usize) -> PrintLimits {
        PrintLimits {
            max_depth,
            max_width,
        }
    }

    #[test]
    fn unlimited_matches_pretty_print() {
        let shape = Shape::one(
            [
                record([
                    ("id", Shape::int([])),
                    ("tags", Shape::list(Shape::string([]), [])),
                    (
                        "nested",
                        record([(
                            "deep",
                            Shape::closed_tuple([Shape::bool([]), Shape::null([])], []),
                        )]),
                    ),
                ]),
                Shape::null([]),
            ],
            [],
        );
        assert_eq!(
            shape.pretty_print_bounded(limits(usize::MAX, usize::MAX)),
            shape.pretty_print(),
        );
    }

    #[test]
    fn elides_below_max_depth() {
        let shape = record([("a", record([("b", record([("c", Shape::int([]))]))]))]);
        assert_eq!(shape.pretty_print_bounded(limits(0, 8)), "…");
        assert_eq!(shape.pretty_print_bounded(limits(1, 8)), "{ a: … }");
        assert_eq!(shape.pretty_print_bounded(limits(2, 8)), "{ a: { b: … } }");
        assert_eq!(
            shape.pretty_print_bounded(limits(3, 8)),
            "{ a: { b: { c: Int } } }",
        );
    }

    #[test]
    fn nullable_unions_do_not_count_as_a_level() {
        let nullable = |shape| Shape::one([shape, Shape::null([])], []);
        let shape = nullable(record([("a", nullable(record([("b", Shape::int([]))])))]));
        assert_eq!(
            shape.pretty_print_bounded(limits(1, 8)),
            "One<{ a: One<…, null> }, null>",
        );
    }

    #[test]
    fn elides_past_max_width() {
        let object = record([
            ("d", Shape::int([])),
            ("a", Shape::int([])),
            ("c", Shape::int([])),
            ("b", Shape::int([])),
        ]);
        // Fields are chosen in sorted order, not insertion order.
        assert_eq!(
            object.pretty_print_bounded(limits(3, 2)),
            "{ a: Int, b: Int, … }"
        );

        let tuple = Shape::closed_tuple([Shape::int([]), Shape::bool([]), Shape::null([])], []);
        assert_eq!(tuple.pretty_print_bounded(limits(3, 2)), "[Int, Bool, …]");

        let one = Shape::one([Shape::int([]), Shape::bool([]), Shape::string([])], []);
        assert_eq!(one.pretty_print_bounded(limits(3, 2)), "One<Int, Bool, …>");

        // Nothing is elided when the width is exactly enough.
        assert_eq!(one.pretty_print_bounded(limits(3, 3)), one.pretty_print());
    }

    #[test]
    fn bounded_on_shared_subtrees() {
        // Each level refers to the next twice, so the full printed form doubles
        // with every level: 2^40 leaves here. Only the bounded print is
        // feasible, and it stays small.
        let mut shape = Shape::int([]);
        for _ in 0..40 {
            shape = record([("a", shape.clone()), ("b", shape)]);
        }
        let printed = shape.pretty_print_bounded(PrintLimits::default());
        assert!(printed.len() < 1_000, "{} bytes:\n{printed}", printed.len());
        assert!(printed.contains('…'));
    }

    #[test]
    fn unions_of_several_composites_count_as_a_level() {
        let a = record([("a", Shape::int([]))]);
        let b = record([("b", Shape::int([]))]);
        let shape = record([("x", Shape::one([a.clone(), b], []))]);
        // `One<{ a }, { b }>` costs a level, so its objects need depth 3.
        assert_eq!(shape.pretty_print_bounded(limits(1, 8)), "{ x: One<…> }");
        assert_eq!(shape.pretty_print_bounded(limits(2, 8)), "{ x: One<…> }");
        assert_eq!(
            shape.pretty_print_bounded(limits(3, 8)),
            "{ x: One<{ a: Int }, { b: Int }> }",
        );
        // A union of one composite shape and scalars stays free.
        let nullable = record([("x", Shape::one([a, Shape::null([])], []))]);
        assert_eq!(
            nullable.pretty_print_bounded(limits(2, 8)),
            "{ x: One<{ a: Int }, null> }",
        );
    }

    #[test]
    fn bounded_on_union_heavy_shape() {
        // Every field is an eight-way union of objects with eight fields each,
        // eight levels deep through shared subtrees: 64^8 leaves. With unions
        // free of charge this printed 2 MB under the default limits.
        let mut variants = (0..8)
            .map(|v| record((0..8).map(|i| (format!("v{v}_f{i}"), Shape::int([])))))
            .collect::<Vec<_>>();
        for _ in 1..8 {
            let union = Shape::one(variants, []);
            variants = (0..8)
                .map(|v| record((0..8).map(|i| (format!("v{v}_f{i}"), union.clone()))))
                .collect();
        }
        let printed = variants[0].pretty_print_bounded(PrintLimits::default());
        assert!(printed.len() < 32_000, "{} bytes", printed.len());
        assert!(printed.contains("One<…>"));
    }

    #[test]
    fn elided_shapes_keep_their_errors() {
        let inner = Shape::error_with_partial(
            "field c is not a String",
            record([("c", Shape::int([]))]),
            [],
        );
        let shape = record([("a", record([("b", inner)]))]);
        assert_eq!(
            shape.pretty_print_bounded(limits(2, 8)),
            r#"{ a: { b: … (err "field c is not a String") } }"#,
        );
        // A shape without errors of its own elides to the bare marker.
        assert_eq!(shape.pretty_print_bounded(limits(0, 8)), "…");
        let top = Shape::error_with_partial("top", record([("a", Shape::int([]))]), []);
        assert_eq!(top.pretty_print_bounded(limits(0, 8)), r#"… (err "top")"#);
    }

    #[test]
    fn width_cutoff_keeps_fields_with_errors() {
        let shape = record([
            ("a", Shape::int([])),
            ("b", Shape::int([])),
            ("z", Shape::error("z is bad", [])),
        ]);
        assert_eq!(
            shape.pretty_print_bounded(limits(3, 2)),
            r#"{ a: Int, z: Unknown (err "z is bad"), … }"#,
        );
        // Nothing is reordered when nothing is cut.
        assert_eq!(
            shape.pretty_print_bounded(limits(3, 3)),
            shape.pretty_print()
        );
    }

    #[test]
    fn elided_union_members_fold_into_one_marker() {
        let shape = Shape::one(
            [
                record([("a", Shape::int([]))]),
                record([("b", Shape::int([]))]),
                Shape::null([]),
            ],
            [],
        );
        assert_eq!(shape.pretty_print_bounded(limits(0, 8)), "One<…, null>");
    }

    #[test]
    fn tails_and_rests_at_the_cutoff() {
        let object = record([("x", Shape::int([]))]);
        let lists = Shape::list(Shape::list(object.clone(), []), []);
        assert_eq!(lists.pretty_print_bounded(limits(1, 8)), "[...…]");
        assert_eq!(
            Shape::dict(object, []).pretty_print_bounded(limits(1, 8)),
            "{...…}"
        );
    }

    #[test]
    fn zero_width() {
        let shape = record([("a", Shape::int([])), ("b", Shape::int([]))]);
        assert_eq!(shape.pretty_print_bounded(limits(3, 0)), "{ … }");
        assert_eq!(
            Shape::closed_tuple([Shape::int([])], []).pretty_print_bounded(limits(3, 0)),
            "[…]",
        );
        assert_eq!(
            Shape::one([Shape::int([]), Shape::bool([])], []).pretty_print_bounded(limits(3, 0)),
            "One<…>",
        );
    }

    #[test]
    fn every_bare_marker_folds_even_when_not_adjacent() {
        let shape = Shape::one(
            [
                record([("a", Shape::int([]))]),
                Shape::null([]),
                record([("b", Shape::int([]))]),
            ],
            [],
        );
        assert_eq!(shape.pretty_print_bounded(limits(0, 8)), "One<…, null>");

        // A marker carrying errors is not bare, and stays.
        let shape = Shape::one(
            [
                Shape::error_with_partial("a bad", record([("a", Shape::int([]))]), []),
                record([("b", Shape::int([]))]),
                record([("c", Shape::int([]))]),
            ],
            [],
        );
        assert_eq!(
            shape.pretty_print_bounded(limits(0, 8)),
            r#"One<… (err "a bad"), …>"#,
        );
    }

    #[test]
    fn union_charge_counts_only_printed_members() {
        let a = record([("a", Shape::int([]))]);
        let b = record([("b", Shape::int([]))]);
        let shape = record([("x", Shape::one([a, b], []))]);
        // At width 1 only one object prints, so the union is free.
        assert_eq!(
            shape.pretty_print_bounded(limits(2, 1)),
            "{ x: One<{ a: Int }, …> }",
        );
    }

    #[test]
    fn union_of_an_object_and_an_array_counts_as_a_level() {
        let shape = record([(
            "x",
            Shape::one(
                [
                    record([("a", Shape::int([]))]),
                    Shape::list(Shape::int([]), []),
                ],
                [],
            ),
        )]);
        assert_eq!(shape.pretty_print_bounded(limits(2, 8)), "{ x: One<…> }");
        assert_eq!(
            shape.pretty_print_bounded(limits(3, 8)),
            "{ x: One<{ a: Int }, [...Int]> }",
        );
    }

    #[test]
    fn width_cutoff_keeps_union_members_with_errors() {
        let shape = Shape::one(
            [
                Shape::int([]),
                Shape::bool([]),
                Shape::error_with_partial("member bad", Shape::string([]), []),
            ],
            [],
        );
        // Kept members stay in their original order.
        assert_eq!(
            shape.pretty_print_bounded(limits(3, 2)),
            r#"One<Int, String (err "member bad"), …>"#,
        );
        // Nothing is reordered when nothing is cut.
        assert_eq!(
            shape.pretty_print_bounded(limits(3, 3)),
            shape.pretty_print()
        );
    }

    #[test]
    fn tuple_elements_stay_positional_at_the_cutoff() {
        let shape = Shape::closed_tuple(
            [
                Shape::int([]),
                Shape::int([]),
                Shape::error("third bad", []),
            ],
            [],
        );
        assert_eq!(shape.pretty_print_bounded(limits(3, 2)), "[Int, Int, …]");
    }

    #[test]
    fn more_error_fields_than_the_width_allows() {
        let shape = record([
            ("c", Shape::error("ec", [])),
            ("a", Shape::error("ea", [])),
            ("b", Shape::error("eb", [])),
            ("d", Shape::int([])),
        ]);
        // Error fields are cut among themselves in key order.
        assert_eq!(
            shape.pretty_print_bounded(limits(3, 2)),
            r#"{ a: Unknown (err "ea"), b: Unknown (err "eb"), … }"#,
        );
    }

    #[test]
    fn intersection_of_several_composites_counts_as_a_level() {
        // Objects merge under `Shape::all`, so pair an object with an array.
        let shape = record([(
            "x",
            Shape::all(
                [
                    record([("a", Shape::int([]))]),
                    Shape::list(Shape::int([]), []),
                ],
                [],
            ),
        )]);
        assert_eq!(shape.pretty_print_bounded(limits(2, 8)), "{ x: All<…> }");
        assert_eq!(
            shape.pretty_print_bounded(limits(3, 8)),
            "{ x: All<[...Int], { a: Int }> }",
        );
    }
}