Method infix_bp

compiler/src/modules/parser/expr.rs:57–113

(&mut self, min_bp: u8)

    }

    pub(super) fn infix_bp(&mut self, min_bp: u8) {
        while let Some(tok) = self.peek() {
            if tok == TokenType::Is {
                if 7 < min_bp { break; }
                self.advance();
                if self.eat_if(TokenType::Not) {
                    self.expr_bp(8);
                    self.chunk.emit(OpCode::IsNot, 0);
                } else {
                    self.expr_bp(8);
                    self.chunk.emit(OpCode::Is, 0);
                }
                continue;
            }

            if tok == TokenType::Not {
                if 7 < min_bp { break; }
                self.advance();
                self.eat(TokenType::In);
                self.expr_bp(8);
                self.chunk.emit(OpCode::NotIn, 0);
                continue;
            }

            let Some((l_bp, r_bp, op)) = Self::binding_power(&tok) else { break };
            if l_bp < min_bp { break; }
            self.advance();

            if matches!(op, OpCode::And | OpCode::Or) {
                let jump_op = if op == OpCode::And { OpCode::JumpIfFalseOrPop } else { OpCode::JumpIfTrueOrPop };
                let jmp = self.emit_jump(jump_op);
                self.expr_bp(r_bp);
                self.patch(jmp);
                continue;
            }

            self.expr_bp(r_bp);

            if matches!(op, OpCode::Eq | OpCode::NotEq | OpCode::Lt | OpCode::Gt | OpCode::LtEq | OpCode::GtEq)
                && let Some(next_tok) = self.peek()
                && matches!(next_tok, TokenType::Less | TokenType::Greater | TokenType::LessEqual | TokenType::GreaterEqual | TokenType::EqEqual | TokenType::NotEqual)
            {
                let ver = self.increment_version(super::SSA_TMP_CMP);
                let tmp = self.push_ssa_name(super::SSA_TMP_CMP, ver);
                self.chunk.emit(OpCode::StoreName, tmp);
                self.chunk.emit(OpCode::LoadName, tmp);
                self.chunk.emit(op, 0);
                let jmp = self.emit_jump(OpCode::JumpIfFalseOrPop);
                self.chunk.emit(OpCode::LoadName, tmp);
                self.infix_bp(min_bp);
                self.patch(jmp);
                return;
            }

            self.chunk.emit(op, 0);
        }
    }