From 1445698a3ca66e84568cd78db4f365ba30855e72 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Thu, 25 Dec 2025 12:27:42 +0100
Subject: [PATCH 1/6] Remove `JumpIfTrueOrPop` & `JumpIfFalseOrPop` opcdes

---
 crates/codegen/src/compile.rs        | 16 ++++++++++++----
 crates/compiler-core/src/bytecode.rs | 21 ---------------------
 crates/vm/src/frame.rs               | 23 -----------------------
 3 files changed, 12 insertions(+), 48 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 4f7174c8bad..fa788eddf9c 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -4030,7 +4030,9 @@ impl Compiler {
             if let Some(ref guard) = m.guard {
                 // Compile guard and jump to end if false
                 self.compile_expression(guard)?;
-                emit!(self, Instruction::JumpIfFalseOrPop { target: end });
+                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::PopJumpIfFalse { target: end });
+                emit!(self, Instruction::Pop);
             }
             self.compile_statements(&m.body)?;
         }
@@ -4101,12 +4103,14 @@ impl Compiler {
 
             // if comparison result is false, we break with this value; if true, try the next one.
             if let Some((break_block, _)) = end_blocks {
+                emit!(self, Instruction::CopyItem { index: 1_u32 });
                 emit!(
                     self,
-                    Instruction::JumpIfFalseOrPop {
+                    Instruction::PopJumpIfFalse {
                         target: break_block,
                     }
                 );
+                emit!(self, Instruction::Pop);
             }
         }
 
@@ -4457,14 +4461,16 @@ impl Compiler {
         let after_block = self.new_block();
 
         let (last_value, values) = values.split_last().unwrap();
+
         for value in values {
             self.compile_expression(value)?;
 
+            emit!(self, Instruction::CopyItem { index: 1_u32 });
             match op {
                 BoolOp::And => {
                     emit!(
                         self,
-                        Instruction::JumpIfFalseOrPop {
+                        Instruction::PopJumpIfFalse {
                             target: after_block,
                         }
                     );
@@ -4472,12 +4478,14 @@ impl Compiler {
                 BoolOp::Or => {
                     emit!(
                         self,
-                        Instruction::JumpIfTrueOrPop {
+                        Instruction::PopJumpIfTrue {
                             target: after_block,
                         }
                     );
                 }
             }
+
+            emit!(self, Instruction::Pop);
         }
 
         // If all values did not qualify, take the value of the last value:
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 11d2a7b5f1b..279429cf359 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -736,20 +736,10 @@ pub enum Instruction {
     },
     /// Performs `is` comparison, or `is not` if `invert` is 1.
     IsOp(Arg<Invert>),
-    /// Peek at the top of the stack, and jump if this value is false.
-    /// Otherwise, pop top of stack.
-    JumpIfFalseOrPop {
-        target: Arg<Label>,
-    },
     /// Performs exception matching for except.
     /// Tests whether the STACK[-2] is an exception matching STACK[-1].
     /// Pops STACK[-1] and pushes the boolean result of the test.
     JumpIfNotExcMatch(Arg<Label>),
-    /// Peek at the top of the stack, and jump if this value is true.
-    /// Otherwise, pop top of stack.
-    JumpIfTrueOrPop {
-        target: Arg<Label>,
-    },
     Jump {
         target: Arg<Label>,
     },
@@ -1617,8 +1607,6 @@ impl Instruction {
             | JumpIfNotExcMatch(l)
             | PopJumpIfTrue { target: l }
             | PopJumpIfFalse { target: l }
-            | JumpIfTrueOrPop { target: l }
-            | JumpIfFalseOrPop { target: l }
             | ForIter { target: l }
             | SetupFinally { handler: l }
             | SetupExcept { handler: l }
@@ -1696,13 +1684,6 @@ impl Instruction {
             Break { .. } => 0,
             Jump { .. } => 0,
             PopJumpIfTrue { .. } | PopJumpIfFalse { .. } => -1,
-            JumpIfTrueOrPop { .. } | JumpIfFalseOrPop { .. } => {
-                if jump {
-                    0
-                } else {
-                    -1
-                }
-            }
             MakeFunction => {
                 // CPython 3.13 style: MakeFunction only pops code object
                 -1 + 1 // pop code, push function
@@ -1910,9 +1891,7 @@ impl Instruction {
             ImportFrom { idx } => w!(ImportFrom, name = idx),
             ImportName { idx } => w!(ImportName, name = idx),
             IsOp(inv) => w!(IS_OP, ?inv),
-            JumpIfFalseOrPop { target } => w!(JumpIfFalseOrPop, target),
             JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
-            JumpIfTrueOrPop { target } => w!(JumpIfTrueOrPop, target),
             Jump { target } => w!(Jump, target),
             ListAppend { i } => w!(ListAppend, i),
             LoadAttr { idx } => w!(LoadAttr, name = idx),
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index d9cc404b47a..3691edb640c 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -981,9 +981,6 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            bytecode::Instruction::JumpIfFalseOrPop { target } => {
-                self.jump_if_or_pop(vm, target.get(arg), false)
-            }
             bytecode::Instruction::JumpIfNotExcMatch(target) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
@@ -1007,9 +1004,6 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            bytecode::Instruction::JumpIfTrueOrPop { target } => {
-                self.jump_if_or_pop(vm, target.get(arg), true)
-            }
             bytecode::Instruction::Jump { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
@@ -2047,23 +2041,6 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
-    #[inline]
-    fn jump_if_or_pop(
-        &mut self,
-        vm: &VirtualMachine,
-        target: bytecode::Label,
-        flag: bool,
-    ) -> FrameResult {
-        let obj = self.top_value();
-        let value = obj.to_owned().try_to_bool(vm)?;
-        if value == flag {
-            self.jump(target);
-        } else {
-            self.pop_value();
-        }
-        Ok(None)
-    }
-
     /// The top of stack contains the iterator, lets push it forward
     fn execute_for_iter(&mut self, vm: &VirtualMachine, target: bytecode::Label) -> FrameResult {
         let top_of_stack = PyIter::new(self.top_value());

From 62259f378328591acce66f5537c9ac2cbad871e3 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Thu, 25 Dec 2025 16:52:40 +0100
Subject: [PATCH 2/6] Use correct instruction name

---
 crates/codegen/src/compile.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 0db407cb07f..ceaf47c77fe 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -4032,7 +4032,7 @@ impl Compiler {
                 self.compile_expression(guard)?;
                 emit!(self, Instruction::CopyItem { index: 1_u32 });
                 emit!(self, Instruction::PopJumpIfFalse { target: end });
-                emit!(self, Instruction::Pop);
+                emit!(self, Instruction::PopTop);
             }
             self.compile_statements(&m.body)?;
         }
@@ -4110,7 +4110,7 @@ impl Compiler {
                         target: break_block,
                     }
                 );
-                emit!(self, Instruction::Pop);
+                emit!(self, Instruction::PopTop);
             }
         }
 
@@ -4485,7 +4485,7 @@ impl Compiler {
                 }
             }
 
-            emit!(self, Instruction::Pop);
+            emit!(self, Instruction::PopTop);
         }
 
         // If all values did not qualify, take the value of the last value:

From 999f6ac380877b6f7fc1c4e7574b90cf716eef37 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Thu, 25 Dec 2025 18:54:52 +0100
Subject: [PATCH 3/6] Extract `compile_cmpop` to its own method

---
 crates/codegen/src/compile.rs | 38 ++++++++++++++++++-----------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index ceaf47c77fe..2fc7fdca004 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -4046,6 +4046,24 @@ impl Compiler {
         Ok(())
     }
 
+    fn compile_cmpop(&mut self, op: &CmpOp) {
+        use bytecode::ComparisonOperator::*;
+        match op {
+            CmpOp::Eq => emit!(self, Instruction::CompareOperation { op: Equal }),
+            CmpOp::NotEq => emit!(self, Instruction::CompareOperation { op: NotEqual }),
+            CmpOp::Lt => emit!(self, Instruction::CompareOperation { op: Less }),
+            CmpOp::LtE => emit!(self, Instruction::CompareOperation { op: LessOrEqual }),
+            CmpOp::Gt => emit!(self, Instruction::CompareOperation { op: Greater }),
+            CmpOp::GtE => {
+                emit!(self, Instruction::CompareOperation { op: GreaterOrEqual })
+            }
+            CmpOp::In => emit!(self, Instruction::ContainsOp(Invert::No)),
+            CmpOp::NotIn => emit!(self, Instruction::ContainsOp(Invert::Yes)),
+            CmpOp::Is => emit!(self, Instruction::IsOp(Invert::No)),
+            CmpOp::IsNot => emit!(self, Instruction::IsOp(Invert::Yes)),
+        }
+    }
+
     fn compile_chained_comparison(
         &mut self,
         left: &Expr,
@@ -4057,22 +4075,6 @@ impl Compiler {
         let (last_op, mid_ops) = ops.split_last().unwrap();
         let (last_val, mid_exprs) = exprs.split_last().unwrap();
 
-        use bytecode::ComparisonOperator::*;
-        let compile_cmpop = |c: &mut Self, op: &CmpOp| match op {
-            CmpOp::Eq => emit!(c, Instruction::CompareOperation { op: Equal }),
-            CmpOp::NotEq => emit!(c, Instruction::CompareOperation { op: NotEqual }),
-            CmpOp::Lt => emit!(c, Instruction::CompareOperation { op: Less }),
-            CmpOp::LtE => emit!(c, Instruction::CompareOperation { op: LessOrEqual }),
-            CmpOp::Gt => emit!(c, Instruction::CompareOperation { op: Greater }),
-            CmpOp::GtE => {
-                emit!(c, Instruction::CompareOperation { op: GreaterOrEqual })
-            }
-            CmpOp::In => emit!(c, Instruction::ContainsOp(Invert::No)),
-            CmpOp::NotIn => emit!(c, Instruction::ContainsOp(Invert::Yes)),
-            CmpOp::Is => emit!(c, Instruction::IsOp(Invert::No)),
-            CmpOp::IsNot => emit!(c, Instruction::IsOp(Invert::Yes)),
-        };
-
         // a == b == c == d
         // compile into (pseudo code):
         // result = a == b
@@ -4099,7 +4101,7 @@ impl Compiler {
             emit!(self, Instruction::Swap { index: 2 });
             emit!(self, Instruction::CopyItem { index: 2_u32 });
 
-            compile_cmpop(self, op);
+            self.compile_cmpop(op);
 
             // if comparison result is false, we break with this value; if true, try the next one.
             if let Some((break_block, _)) = end_blocks {
@@ -4116,7 +4118,7 @@ impl Compiler {
 
         // handle the last comparison
         self.compile_expression(last_val)?;
-        compile_cmpop(self, last_op);
+        self.compile_cmpop(last_op);
 
         if let Some((break_block, after_block)) = end_blocks {
             emit!(

From 186b9145364764b9755df9b8b8b12fcf53e11626 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Fri, 26 Dec 2025 11:47:47 +0100
Subject: [PATCH 4/6] Better alignment with CPython code

---
 crates/codegen/src/compile.rs | 103 +++++++++++++++++-----------------
 1 file changed, 50 insertions(+), 53 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 2fc7fdca004..bca9dcaa0a3 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -4046,7 +4046,8 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_cmpop(&mut self, op: &CmpOp) {
+    /// [CPython `compiler_addcompare`](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Python/compile.c#L2880-L2924)
+    fn compile_addcompare(&mut self, op: &CmpOp) {
         use bytecode::ComparisonOperator::*;
         match op {
             CmpOp::Eq => emit!(self, Instruction::CompareOperation { op: Equal }),
@@ -4064,78 +4065,74 @@ impl Compiler {
         }
     }
 
-    fn compile_chained_comparison(
+    /// Compile a chained comparison.
+    ///
+    /// ```py
+    /// a == b == c == d
+    /// ```
+    ///
+    /// Will compile into (pseudo code):
+    ///
+    /// ```py
+    /// result = a == b
+    /// if result:
+    ///   result = b == c
+    ///   if result:
+    ///     result = c == d
+    /// ```
+    ///
+    /// # See Also
+    /// - [CPython `compiler_compare`](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Python/compile.c#L4678-L4717)
+    fn compile_compare(
         &mut self,
         left: &Expr,
         ops: &[CmpOp],
-        exprs: &[Expr],
+        comparators: &[Expr],
     ) -> CompileResult<()> {
-        assert!(!ops.is_empty());
-        assert_eq!(exprs.len(), ops.len());
         let (last_op, mid_ops) = ops.split_last().unwrap();
-        let (last_val, mid_exprs) = exprs.split_last().unwrap();
-
-        // a == b == c == d
-        // compile into (pseudo code):
-        // result = a == b
-        // if result:
-        //   result = b == c
-        //   if result:
-        //     result = c == d
+        let (last_comparator, mid_comparators) = comparators.split_last().unwrap();
 
         // initialize lhs outside of loop
         self.compile_expression(left)?;
 
-        let end_blocks = if mid_exprs.is_empty() {
-            None
-        } else {
-            let break_block = self.new_block();
-            let after_block = self.new_block();
-            Some((break_block, after_block))
-        };
+        if mid_comparators.is_empty() {
+            self.compile_expression(last_comparator)?;
+            self.compile_addcompare(last_op);
+
+            return Ok(());
+        }
+
+        let cleanup = self.new_block();
 
         // for all comparisons except the last (as the last one doesn't need a conditional jump)
-        for (op, val) in mid_ops.iter().zip(mid_exprs) {
-            self.compile_expression(val)?;
+        for (op, comparator) in mid_ops.iter().zip(mid_comparators) {
+            self.compile_expression(comparator)?;
+
             // store rhs for the next comparison in chain
             emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::CopyItem { index: 2_u32 });
+            emit!(self, Instruction::CopyItem { index: 2 });
 
-            self.compile_cmpop(op);
+            self.compile_addcompare(op);
 
             // if comparison result is false, we break with this value; if true, try the next one.
-            if let Some((break_block, _)) = end_blocks {
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
-                emit!(
-                    self,
-                    Instruction::PopJumpIfFalse {
-                        target: break_block,
-                    }
-                );
-                emit!(self, Instruction::PopTop);
-            }
+            emit!(self, Instruction::CopyItem { index: 1 });
+            // emit!(self, Instruction::ToBool); // TODO: Uncomment this
+            emit!(self, Instruction::PopJumpIfFalse { target: cleanup });
+            emit!(self, Instruction::PopTop);
         }
 
-        // handle the last comparison
-        self.compile_expression(last_val)?;
-        self.compile_cmpop(last_op);
-
-        if let Some((break_block, after_block)) = end_blocks {
-            emit!(
-                self,
-                Instruction::Jump {
-                    target: after_block,
-                }
-            );
+        self.compile_expression(last_comparator)?;
+        self.compile_addcompare(last_op);
 
-            // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
-            self.switch_to_block(break_block);
-            emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::PopTop);
+        let end = self.new_block();
+        emit!(self, Instruction::Jump { target: end });
 
-            self.switch_to_block(after_block);
-        }
+        // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
+        self.switch_to_block(cleanup);
+        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::PopTop);
 
+        self.switch_to_block(end);
         Ok(())
     }
 
@@ -4564,7 +4561,7 @@ impl Compiler {
                 comparators,
                 ..
             }) => {
-                self.compile_chained_comparison(left, ops, comparators)?;
+                self.compile_compare(left, ops, comparators)?;
             }
             // Expr::Constant(ExprConstant { value, .. }) => {
             //     self.emit_load_const(compile_constant(value));

From 48f377228a4c4ff94d2448c32a97d3769d1fed69 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Fri, 26 Dec 2025 11:55:16 +0100
Subject: [PATCH 5/6] Restore `PopJumpIf` instructions

---
 crates/compiler-core/src/bytecode.rs | 21 +++++++++++++++++++++
 crates/vm/src/frame.rs               | 23 +++++++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index cd24944ff98..dd49e679f27 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -736,10 +736,20 @@ pub enum Instruction {
     },
     /// Performs `is` comparison, or `is not` if `invert` is 1.
     IsOp(Arg<Invert>),
+    /// Peek at the top of the stack, and jump if this value is false.
+    /// Otherwise, pop top of stack.
+    JumpIfFalseOrPop {
+        target: Arg<Label>,
+    },
     /// Performs exception matching for except.
     /// Tests whether the STACK[-2] is an exception matching STACK[-1].
     /// Pops STACK[-1] and pushes the boolean result of the test.
     JumpIfNotExcMatch(Arg<Label>),
+    /// Peek at the top of the stack, and jump if this value is true.
+    /// Otherwise, pop top of stack.
+    JumpIfTrueOrPop {
+        target: Arg<Label>,
+    },
     Jump {
         target: Arg<Label>,
     },
@@ -1611,6 +1621,8 @@ impl Instruction {
             | JumpIfNotExcMatch(l)
             | PopJumpIfTrue { target: l }
             | PopJumpIfFalse { target: l }
+            | JumpIfTrueOrPop { target: l }
+            | JumpIfFalseOrPop { target: l }
             | ForIter { target: l }
             | SetupFinally { handler: l }
             | SetupExcept { handler: l }
@@ -1688,6 +1700,13 @@ impl Instruction {
             Break { .. } => 0,
             Jump { .. } => 0,
             PopJumpIfTrue { .. } | PopJumpIfFalse { .. } => -1,
+            JumpIfTrueOrPop { .. } | JumpIfFalseOrPop { .. } => {
+                if jump {
+                    0
+                } else {
+                    -1
+                }
+            }
             MakeFunction => {
                 // CPython 3.13 style: MakeFunction only pops code object
                 -1 + 1 // pop code, push function
@@ -1895,7 +1914,9 @@ impl Instruction {
             ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
             ImportName { idx } => w!(IMPORT_NAME, name = idx),
             IsOp(inv) => w!(IS_OP, ?inv),
+            JumpIfFalseOrPop { target } => w!(JUMP_IF_FALSE_OR_POP, target),
             JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
+            JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
             Jump { target } => w!(JUMP, target),
             ListAppend { i } => w!(LIST_APPEND, i),
             LoadAttr { idx } => w!(LOAD_ATTR, name = idx),
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 4bc34bfbfb0..e9a938ba023 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -981,6 +981,9 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
+            bytecode::Instruction::JumpIfFalseOrPop { target } => {
+                self.jump_if_or_pop(vm, target.get(arg), false)
+            }
             bytecode::Instruction::JumpIfNotExcMatch(target) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
@@ -1004,6 +1007,9 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 self.pop_jump_if(vm, target.get(arg), false)
             }
+            bytecode::Instruction::JumpIfTrueOrPop { target } => {
+                self.jump_if_or_pop(vm, target.get(arg), true)
+            }
             bytecode::Instruction::Jump { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
@@ -2041,6 +2047,23 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
+    #[inline]
+    fn jump_if_or_pop(
+        &mut self,
+        vm: &VirtualMachine,
+        target: bytecode::Label,
+        flag: bool,
+    ) -> FrameResult {
+        let obj = self.top_value();
+        let value = obj.to_owned().try_to_bool(vm)?;
+        if value == flag {
+            self.jump(target);
+        } else {
+            self.pop_value();
+        }
+        Ok(None)
+    }
+
     /// The top of stack contains the iterator, lets push it forward
     fn execute_for_iter(&mut self, vm: &VirtualMachine, target: bytecode::Label) -> FrameResult {
         let top_of_stack = PyIter::new(self.top_value());

From 582d1e03c6a1a78962c73714bb2599e52d3b5908 Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Fri, 26 Dec 2025 12:13:26 +0100
Subject: [PATCH 6/6] Revert PopJumpIfFalse for comparisons

---
 crates/codegen/src/compile.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index bca9dcaa0a3..8d4d35c0fc4 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -4115,10 +4115,14 @@ impl Compiler {
             self.compile_addcompare(op);
 
             // if comparison result is false, we break with this value; if true, try the next one.
+            /*
             emit!(self, Instruction::CopyItem { index: 1 });
             // emit!(self, Instruction::ToBool); // TODO: Uncomment this
             emit!(self, Instruction::PopJumpIfFalse { target: cleanup });
             emit!(self, Instruction::PopTop);
+            */
+
+            emit!(self, Instruction::JumpIfFalseOrPop { target: cleanup });
         }
 
         self.compile_expression(last_comparator)?;