[red-knot] Output is not colorised even if `--color=always` is specified with `--output-format=concise`

[AlexWaygood]

Summary

If you specify --output-format=concise, --color appears to have no effect. This makes the output quite hard to read:

And it's different to what Ruff does with --output-format=concise:

[MichaReiser]

@BurntSushi could you take a look at this. This is probably easy to fix (I assume we simply aren't colorizing the output)

[Kalmaegi]

Can I try to fix this issue?

[BurntSushi]

@Kalmaegi Go for it! I haven't started this yet, so it's all yours.

[Kalmaegi]

https://github.com/astral-sh/ruff/blob/main/crates/ruff_db/src/diagnostic/render.rs#L61-L85

impl std::fmt::Display for DisplayDiagnostic<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        if matches!(self.config.format, DiagnosticFormat::Concise) {
            match self.diag.severity() {
                Severity::Info => f.write_str("info")?,
                Severity::Warning => f.write_str("warning")?,
                Severity::Error => f.write_str("error")?,
                Severity::Fatal => f.write_str("fatal")?,
            }

            write!(f, "[{rule}]", rule = self.diag.id())?;
            if let Some(span) = self.diag.primary_span() {
                write!(f, " {path}", path = self.resolver.path(span.file()))?;
                if let Some(range) = span.range() {
                    let input = self.resolver.input(span.file());
                    let start = input.as_source_code().source_location(range.start());
                    write!(f, ":{line}:{col}", line = start.row, col = start.column)?;
                }
                write!(f, ":")?;
            }
            return writeln!(f, " {}", self.diag.concise_message());
        }

        let resolved = Resolved::new(&self.resolver, self.diag);
        let renderable = resolved.to_renderable(self.config.context);
        for diag in renderable.diagnostics.iter() {
            writeln!(f, "{}", self.annotate_renderer.render(diag.to_annotate()))?;
        }
        writeln!(f)
    }
}

I think I might have found the issue. Currently, for the concise mode, we manually concatenate and call write for output, while for the full mode, we construct a render object. I can think of two possible fixes, but I'm not sure which one is better:

Add color handling directly in the write section of the concise branch – straightforward, but a bit tedious.

Alternatively, could we also construct a render object for primary_span, letting it handle colors internally?

I'm not entirely sure if my approach is correct. Any help would be greatly appreciated!

[BurntSushi]

I think any way you slice it, you'll need to add colors the tedious way. If you make a render object, that will do the "verbose" output. So the concise output fundamentally has to do its own thing and add colors to itself.