Is it possible to render errors based on line number and then the column? My parser resets the column position on each new line, so rendering errors is difficult since an error on the 4th line at column 4..5 is being rendered as the 4th and 5th characters in the entire source.

I have a perhaps odd situation where I'm dealing with chunks of text out of a larger file, so to get the correct line number I need to add an offset value. I implemented this here https://github.com/olson-dan/ariadne/commit/3b66508bafd6de14f8c1c57546e9a5136d1cb861 but it seems like rustfmt made a mess of this commit. Are you interested in the change at all? Maybe adding a rustfmt config to the main branch could help with this type of situation.

Hey, I was trying to get started with Ariadne and grabbed an example from the README, but it does not render as expected:

What I got:

What README shows:

Tested with 0.1.5 and 0.1.3.

I was about to open a PR to fix this, the spans are a bit behind for the example in README and examples/sample.rs, however, I just wanted to confirm, can you reproduce this?

EDIT: updated image.

Currently spans in ariadne reference characters and not bytes. Because converting between char indices and byte indices can be cumbersome it would be nice if both variants would be supported.

This PR adds Report::with_labels, a chainable equivalent of Report::add_labels. This brings a minor DX improvement for the common use case where a report includes an iterable of errors, such as when parsing input with chumsky.

Before

if let Err(errors) = parser().parse(&input) {
    let mut report =
        Report::build(ReportKind::Error, &filename, 0).with_message("Error parsing file");
    report.add_labels(errors.iter().map(|error| {
        Label::new((&filename, error.span())).with_message(format!("{}", error))
    }));
    report
        .finish()
        .eprint((&filename, Source::from(&input)))
        .unwrap();
}

After

if let Err(errors) = parser().parse(&input) {
    Report::build(ReportKind::Error, &filename, 0)
        .with_message("Error parsing file");
        .with_labels(errors.iter().map(|error| {
            Label::new((&filename, error.span())).with_message(format!("{}", error))
        }))
        .finish()
        .eprint((&filename, Source::from(&input)))
        .unwrap();
}

In just testing some byte offset to char index conversion code, I noticed https://github.com/zesterer/ariadne/issues/41

When testing with "🦀". Naively just modifying char_width() prints multiple instances of the unicode character in question. "🦀" becomes "🦀🦀",

I left this behavior enabled for whitespace since I believe it is a part of the treatment of '\t' tab characters.

This perhaps doesn't fully fix the issue as reported, they might need a boolean to Config setting, which sets things up to call either width and width_cjk, but I don't know the right behavior to shoot for regarding whitespace in cjk.

I'm in the process of writing a Python wrapper for ariadne, but ReportKind::Custom has a member with a 'static lifetime, making it impossible to use across FFI boundaries. This change relaxes the 'static lifetime, making it possible to use ReportKind::Custom across FFI.

Here is a most crucial contribution. I hope the feature improvements in this pull request really help make ariadne a better project overall. Jokes aside, thank you for the excellent work.

OS: Windows Version of ariadne: I'm using git version

minimal code:

Report::build(ReportKind::Error, error.span.file_id, error.span.range.0)
.with_code(1)
.with_message(error.error_message)
.with_label(Label::new(error.span).with_color(red))
.finish()
.print(sources(vec![("test.vnl", &self.source)]))
.unwrap();

output:

I wonder how could this be integrated into LSP, to forward the diagnostics to the editor(s).

P.D: Comming from https://www.reddit.com/r/rust/comments/okza9q/i_just_released_ariadne_a_crate_for_generating/h5bqd1j

Would be useful to be able to suggest edits in a note/help message similar to how rust does it.

Need to be able to provide a new version of the line/file, not sure how that would work.

Line, Source, FileCache, Label, Report, etc. do not implement any of Clone, Debug, PartialEq, etc.

This makes it hard to use them in types that do need to implement those. Implementing them should be a trivial #[derive(…)] macro.

See also C-COMMON-TRAITS in the Rust API Guidelines.

Despite setting this to false, the colors are shown when added to labels:

pub fn build_report(
    named: String,
    err: &ErrorParser,
) -> Report<(String, Range<usize>)> {
    let mut colors = ColorGenerator::new();

    // Generate some colours for each of our elements
    let primary = colors.next();
    // let secondary = colors.next();
    let code = err.error_code();
    let config = Config::default().with_color(false);
    let diagnostic = Report::build(ReportKind::Error, named.clone(), 0)
        .with_code(code as usize)
        .with_config(config);

    match err {
        ErrorParser::ScalarParse { span, kind, msg } => diagnostic
            .with_message(msg)
            .with_label(
                Label::new((named, span.range()))
                    .with_message(msg)
                    .with_color(primary), <-- THIS CAUSE IT TO SHOW COLORS
            )
            .with_note(format!("Parsing value of type: {kind:?}"))
            .finish(),
        _ => {
            todo!()
        }
    }
}

New to this crate, so not sure if I'm simply doing something wrong but it seems like you can't build reports with non-static values:

Report::build(ReportKind::Error, ...)
    .with_message(...)
    with_label(Label::new((data.file.as_str(), span)))

data.file is a String instance, my main function calls another function passing data which then builds the report. Borrowed data either escapes the function body or doesn't outlive 'static as required

Firstly thank you for the excellent library! We're heavily using it in PRQL.

In PRQL we have a pre-commit action which removes trailing whitespace. It seems that ariadne's outputs have trailing whitespace, so inline snapshot tests can't pass. Here's an example: https://github.com/prql/prql/commit/80ae4319e1558e81025f6f72fe5f87f851e6fcda, from https://github.com/prql/prql/pull/1181.

Would it be reasonable to strip trailing whitespace? Or is that too narrow a goal? It's not that critical for us; we can move to using snapshot tests in .snap files if needed.

Thanks again

Consider this example:

use ariadne::*;

const TEXT: &str = "a b c d";

fn report_n_labels(n: usize) {
    let mut report = Report::build(ReportKind::Error, (), 0);
    for i in 0..n {
        report = report.with_label(Label::new(i * 2..i * 2 + 1));
    }
    report.finish().print(Source::from(TEXT)).unwrap();
}

fn main() {
    for n in 1..=4 {
        report_n_labels(n);
    }
}

This gives output:

Error: 
   ╭─[<unknown>:1:1]
   │
 1 │ a b c d
   · ─
   ·
───╯
Error:
   ╭─[<unknown>:1:1]
   │
 1 │ a b c d
   · ─ ─
   ·
   ·
   ·
───╯
Error:
   ╭─[<unknown>:1:1]
   │
 1 │ a b c d
   · ─ ─ ─
   ·
   ·
   ·
   ·
   ·
───╯
Error:
   ╭─[<unknown>:1:1]
   │
 1 │ a b c d
   · ─ ─ ─ ─
   ·
   ·
   ·
   ·
   ·
   ·
   ·
───╯

It looks like labels add extra vertical space for their messages even if they don't have messages. This occurs with compact mode too. I think this is undesirable.