A fancy compiler diagnostics crate.
fn main() {
use ariadne::{Color, ColorGenerator, Fmt, Label, Report, ReportKind, Source};
let mut colors = ColorGenerator::new();
// Generate & choose some colours for each of our elements
let a = colors.next();
let b = colors.next();
let out = Color::Fixed(81);
Report::build(ReportKind::Error, "sample.tao", 12)
.with_code(3)
.with_message(format!("Incompatible types"))
.with_label(
Label::new(("sample.tao", 32..33))
.with_message(format!("This is of type {}", "Nat".fg(a)))
.with_color(a),
)
.with_label(
Label::new(("sample.tao", 42..45))
.with_message(format!("This is of type {}", "Str".fg(b)))
.with_color(b),
)
.with_label(
Label::new(("sample.tao", 11..48))
.with_message(format!(
"The values are outputs of this {} expression",
"match".fg(out),
))
.with_color(out),
)
.with_note(format!(
"Outputs of {} expressions must coerce to the same type",
"match".fg(out)
))
.finish()
.print(("sample.tao", Source::from(include_str!("sample.tao"))))
.unwrap();
}
See examples/
for more examples.
For each error you wish to report:
- Call
Report::build()
to create aReportBuilder
. - Assign whatever details are appropriate to the error using the various
methods, and then call the
finish
method to get aReport
. - For each
Report
, callprint
oreprint
to write the report directly tostdout
orstderr
. Alternately, you can usewrite
to send the report to any otherWrite
destinarion (such as a file).
ariadne
is a sister project of chumsky
. Neither are dependent on
one-another, but I'm working on both simultaneously and like to think that their features complement each other. If
you're thinking of using ariadne
to process your compiler's output, why not try using chumsky
to process its input?
- Inline and multi-line labels capable of handling arbitrary configurations of spans
- Multi-file errors
- Generic across custom spans and file caches
- A choice of character sets to ensure compatibility
- Coloured labels & highlighting with 8-bit and 24-bit color support (thanks to
yansi
) - Label priority and ordering
- Compact mode for smaller diagnostics
- Correct handling of variable-width characters such as tabs
- A
ColorGenerator
type that generates distinct colours for visual elements. - A plethora of other options (tab width, label attach points, underlines, etc.)
- Built-in ordering/overlap heuristics that come up with the best way to avoid overlapping & label crossover
"concolor"
enables integration with theconcolor
crate for global color output control across your application"auto-color"
enablesconcolor
's"auto"
feature for automatic color control
concolor
's features should be defined by the top-level binary crate, but without any features enabled concolor
does
nothing. If ariadne
is your only dependency using concolor
then "auto-color"
provides a convenience to enable
concolor
's automatic color support detection, i.e. this:
[dependencies]
ariadne = { version = "...", features = ["auto-color"] }
is equivalent to this:
[dependencies]
ariadne = { version = "...", features = ["concolor"] }
concolor = { version = "...", features = ["auto"] }
- Improved layout planning & space usage
- Non-ANSI terminal support
- More accessibility options (screenreader-friendly mode, textured highlighting as an alternative to color, etc.)
- More color options
- Better support for layout restrictions (maximum terminal width, for example)
The API (should) follow semver. However, this does not apply to the layout of final error messages. Minor tweaks to the internal layout heuristics can often result in the exact format of error messages changing with labels moving slightly. If you experience a change in layout that you believe to be a regression (either the change is incorrect, or makes your diagnostics harder to read) then please open an issue.
Thanks to:
-
@brendanzab
for their beautifulcodespan
crate that inspired me to try pushing the envelope of error diagnostics. -
@estebank
for showing innumerable people just how good compiler diagnostics can be through their work on Rust.