How does error recovery work?

[Divy1211]

Hi all! I've been using chumsky to make an LSP for a custom language, but one thing that has me confused for a while is how to make proper error recovery. Currently, my parser stops as soon as a lexer/parser error is encountered, and this isn't ideal for an LSP, or autocomplete. I've tried a few things:

• Using the recover_with() API, but the only strategy that I got to work was .recover_with(skip_then_retry_until(any().ignored(), end())) which isn't ideal, because it lets you insert invalid syntax between otherwise valid syntax.
• Any other strategy I tried with recover_with() API gave me massive "trait bounds not satisfied" errors, which I don't really understand
• Alternatively, I added "Error" nodes to my AST and Token enums, to try and add fallback parsers at the end of my usual parsers that would consume any tokens until some known "resync" points (semi colons, braces, etc.) are reached, but I didn't get very far with this, because while this approach actually works for lexing, it doesn't play nicely with a recursive parser, because things like parser.repeated() and parser.delimited_by() will incorrectly consume delimiters themselves because the parser has a general fallback which will consume any token until the defined resync points. I realised that delimited_by and similar parsers require the inner parser to fail so that it stops consuming tokens.

So my question is: What is the proper way to go about error recovery?

[zesterer]

The most general approach is via_parser (yep, it needs some more docs). It allows you to specify a 'fallback parser' that catches and discards erroneous input, providing a fallback output instead. Conceptually, it's a lot like .or. The behaviour of the following two parsers are the same:

a.or(b)

a.recover_with(via_parser(b))

With the exception that the error from a gets 'remembered' and emitted as a non-fatal error.

There are other error recovery strategies, such as skip_then_retry_until (which you mention) but most of these exist to ease the transition from 0.9, which did not have via_parser. However, the others can be implemented in terms of via_parser, which is the more general way to do error recovery.

[Divy1211]

I'll give this a go as well. How does it work with recursive parsers? In terms of the problem I described above, with parsers like delimited_by/repeated never terminating with a simple catch-all .or

[zesterer]

It works as you might expect with recursive parsers (i.e: the two features are independent and compose appropriately).