Method parse_binary_expr_rest

crates/parser/src/expr.rs:359–426

(
        &mut self,
        prec: BinPrec,
        left: &'cx ast::Expr<'_>,
        start: u32,
    )

                }
                ast::ExprKind::PropAccess(_)
                | ast::ExprKind::EleAccess(_)
                | ast::ExprKind::ArrayLit(_)
                | ast::ExprKind::ObjectLit(_) => {}
                _ => {
                    let error = errors::TheLeftHandSideOfAnAssignmentExpressionMustBeAVariableOrAPropertyAccess {
                        span: expr.span()
                    };
                    self.push_error(Box::new(error));
                }
            }
            let op = self.token.kind.into();
            self.next_token();
            let right = self.parse_assign_expr_or_higher::<ALLOW_RET_TY_IN_ARROW_FN>()?;
            let expr = self.create_assignment_expression(self.new_span(start), expr, op, right);
            let expr = self.alloc(ast::Expr {
                kind: ast::ExprKind::Assign(expr),
            });
            Ok(expr)
        } else {
            self.parse_cond_expr_rest::<ALLOW_RET_TY_IN_ARROW_FN>(expr)
        }
    }

    pub(super) fn parse_binary_expr(&mut self, prec: BinPrec) -> PResult<&'cx ast::Expr<'cx>> {
        let start = self.token.start();
        let left = self.parse_unary_expr()?;
        self.parse_binary_expr_rest(prec, left, start)
    }

    fn parse_binary_expr_rest(
        &mut self,
        prec: BinPrec,
        left: &'cx ast::Expr<'_>,
        start: u32,
    ) -> PResult<&'cx ast::Expr<'cx>> {
        let mut left = left;
        loop {
            self.re_scan_greater();

            let next_prec = self.token.kind.prec();
            let consume = if self.token.kind == TokenKind::AsteriskAsterisk {
                next_prec >= prec
            } else {
                next_prec > prec
            };
            if !consume {
                break Ok(left);
            }
            if self.token.kind == TokenKind::In && self.in_disallow_in_context() {
                break Ok(left);
            }

            if matches!(self.token.kind, TokenKind::As | TokenKind::Satisfies)
                && self.has_preceding_line_break()
            {
                break Ok(left);
            }