Function parse_let_or_letrec_old

src/expr-parser/src/parser.rs:193–218

Parses a Let or a LetRec with the old order: Return first, and then CTEs in descending order.

(ctx: CtxRef, input: ParseStream)

    /// Parses a Let or a LetRec with the old order: Return first, and then CTEs in descending order.
    fn parse_let_or_letrec_old(ctx: CtxRef, input: ParseStream) -> Result {
        let return_ = input.parse::<kw::Return>()?;
        let parse_body = ParseChildren::new(input, return_.span().start());
        let body = parse_body.parse_one(ctx, parse_expr)?;

        let with = input.parse::<kw::With>()?;
        let recursive = input.eat2(kw::Mutually, kw::Recursive);
        let parse_ctes = ParseChildren::new(input, with.span().start());
        let mut ctes = parse_ctes.parse_many(ctx, parse_cte)?;

        if ctes.is_empty() {
            let msg = "At least one Let/LetRec cte binding expected";
            Err(Error::new(input.span(), msg))?
        }

        ctes.reverse();
        let cte_ids = ctes.iter().map(|(id, _, _)| id);
        if !cte_ids.clone().is_sorted() {
            let msg = format!(
                "Error parsing Let/LetRec: seen Return before With, but cte ids are not ordered descending: {:?}",
                cte_ids.collect::<Vec<_>>()
            );
            Err(Error::new(input.span(), msg))?
        }
        build_let_or_let_rec(ctes, body, recursive, with)
    }

    /// Parses a Let or a LetRec with the new order: CTEs first in ascending order, and then Return.
    fn parse_let_or_letrec(ctx: CtxRef, input: ParseStream) -> Result {