Method fmt

assert-struct/src/error.rs:317–379

(&self, f: &mut fmt::Formatter<'_>)

impl fmt::Display for ErrorReport {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.errors.is_empty() {
            return Ok(());
        }

        let source_content = cached_source(&self.abs_path);

        // Pre-compute labels so their lifetimes outlive the report construction.
        let labels: Vec<String> = self.errors.iter().map(error_label).collect();

        let renderer = if PLAIN_OUTPUT.with(|c| c.get())
            || std::env::var_os("NO_COLOR").is_some()
            || !std::io::IsTerminal::is_terminal(&std::io::stderr())
        {
            Renderer::plain()
        } else {
            Renderer::styled()
        };

        if let Some(source) = &source_content {
            let annotations: Vec<_> = self
                .errors
                .iter()
                .zip(labels.iter())
                .map(|(error, label)| {
                    let start = byte_offset_of(
                        source,
                        error.error_node.line_start,
                        error.error_node.col_start,
                    );
                    let end =
                        byte_offset_of(source, error.error_node.line_end, error.error_node.col_end)
                            .max(start + 1);
                    AnnotationKind::Primary
                        .span(start..end)
                        .label(label.as_str())
                })
                .collect();

            let snippet = Snippet::source(&**source)
                .line_start(1)
                .path(&self.rel_path)
                .annotations(annotations);

            let report = Level::ERROR
                .primary_title("assert_struct! failed")
                .element(snippet);

            write!(f, "{}", renderer.render(&[report]))?;
        } else {
            // Fallback when the source file cannot be read: show location + description.
            write!(f, "assert_struct! failed:")?;
            for (error, label) in self.errors.iter().zip(labels.iter()) {
                write!(
                    f,
                    "\n  --> {}:{}\n  {label}",
                    self.rel_path, error.error_node.line_start
                )?;