.or() taking wrong parser

[uyuF]

I am using chumsky 0.9.3 for an assignment so I won't be able to share my actual code, but I've been experiencing an issue where the order of my parsers using or seems to be getting ignored.

The language I am writing the parser for is a LOGO spinoff.

For context, my program works fine until I introduce function calls which result in a stack overflow, and when I added some printing to debug, it showed that the program was always choosing the function call parser even though it is the last parser in the chain. The previous parsers should match all the other identifiers like "PENDOWN", "IF", "WHILE", etc., and then any identifier that isn't predefined in the language is supposed to be parsed as a function call.

With the function call parser commented out, the other parsers work fine.

I've tried writing the call parser inside the recursive block like the foo example, as well as outside the recursive block but it gives the same behaviour.

 rec_expr = recursive(|expr| {
    // different parsers here covering atoms and predefined identifiers
    choice ((
      num // following 3 are prefixed by ",
      bool,
      string,
      var // prefixed by :,
      ident // various identifiers which are just strings i.e. PENDOWN,
      ...
      // First attempt: I've tried putting the call parser here
    )).padded()
  }

  let arg_parser = rec_expr.clone().separated_by(just(' ')).then_ignore(just('\n'));
  let func_body_parser = rec_expr.clone().repeated().then_ignore(just("END"));
  let func_parser = text::keyword("TO").padded()
    .then(string_parser()) // similar to text::ident(), but takes all strings not just alphanumeric + _
    .then(arg_parser)
    .then(func_body_parser)
    .map(|(((_, name), args), body)| Expr::Procedure(name, args, body));
    // Second attempt: I tried placing the call parser outside the recursive block and having the parser last
   // so that it hopefully only gets called after all the other identifiers have been parsed
    let call_parser = string_parser()
      .then(rec_expr.clone().repeated().then_ignore(just('\n')))
      .map(|(name, args)| {
          Expr::Call(name, args)
      });
  func_parser.or(rec_expr).or(call_parser).repeated().then_ignore(end());

Am I doing something wrong or is this a bug?
Should I just rewrite in version 1.0.0?

[zesterer]

Stack overflow is almost always due to left recursion, which happens when a parser appears in left-most position within itself. I suspect that rec_expr is to blame, but there's not enough information about it in your code snippet to tell.

[Zij-IT]

As a heads up, inside of a recursive call, style-wise you should clone expr instead of rec_expr :) With the way that you have it written, you are basically using Recursive::declare and Recursive::define.

I agree however with Zesterer, that there isn't enough information here to really be able to provide you a solution. If it helps though, I can recommend that you take a look at how the Rust-Nano example handles function calls, as it may help to see how it is recommended to go about parsing expression.

Best of luck!

[uyuF]

After a bit of bug testing I think the issue lays with my string parser which the call parser uses

fn string_parser() -> impl Parser<char, String, Error = Simple<char>> {
    filter(|c: &char| !c.is_whitespace())
    .repeated()
    .collect::<String>()
}

No matter what code I use as input, i.e.

PENDOWN

It would always go to the call parser, which prints the result "Parsing: " over and over until the program crashes, I'm not too sure but I think it's trying to parse an empty character or maybe the end of file character

I fixed this by changing my string parser to be similar to text::ident()

[zesterer]

Are you sure the string parser is being hit at all? I see nothing in the way of bugs in the string parser (although it's worth noting that it will also accept punctuation and the like).

[uyuF]

I added a print statement to the call_parser which ended up printing until the program crashed
let call_parser = string_parser().padded().map(|ident| { println!("Parsed as call: {string}"); string });

Fixing the string_parser resolved the crashes, but now it gets called over my IF, WHILE and function declaration parsers

I had to blacklist some identifiers in my call parser to get it to work properly

[zesterer]

So, is this resolved?

[uyuF]

Yes