Add compile_bool_op_inner and optimize nested opposite-operator BoolOps to avoid redundant __bool__ calls

moreal · claude · moreal · commit 11152d4b5f0d · 2026-02-17T21:23:02.000+09:00
When a nested BoolOp has the opposite operator (e.g., `And` inside `Or`),
the inner BoolOp's short-circuit exits are redirected to skip the outer
BoolOp's redundant truth test. This avoids calling `__bool__()` twice on
the same value (e.g., `Test() and False or False` previously called
`Test().__bool__()` twice instead of once).

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -6616,6 +6616,44 @@ impl Compiler {
         let (last_value, values) = values.split_last().unwrap();
 
         for value in values {
+            // Optimization: when a non-last value is a BoolOp with the opposite
+            // operator, redirect its short-circuit exits to skip the outer's
+            // redundant __bool__ test (jump threading).
+            if let ast::Expr::BoolOp(ast::ExprBoolOp {
+                op: inner_op,
+                values: inner_values,
+                ..
+            }) = value
+            {
+                if inner_op != op {
+                    let pop_block = self.new_block();
+                    self.compile_bool_op_inner(inner_op, inner_values, Some(pop_block))?;
+                    // Test the inner result for the outer BoolOp
+                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    match op {
+                        ast::BoolOp::And => {
+                            emit!(
+                                self,
+                                Instruction::PopJumpIfFalse {
+                                    target: after_block,
+                                }
+                            );
+                        }
+                        ast::BoolOp::Or => {
+                            emit!(
+                                self,
+                                Instruction::PopJumpIfTrue {
+                                    target: after_block,
+                                }
+                            );
+                        }
+                    }
+                    self.switch_to_block(pop_block);
+                    emit!(self, Instruction::PopTop);
+                    continue;
+                }
+            }
+
             self.compile_expression(value)?;
 
             emit!(self, Instruction::Copy { index: 1_u32 });
@@ -6647,6 +6685,54 @@ impl Compiler {
         Ok(())
     }
 
+    /// Compile a boolean operation as an expression, with an optional
+    /// short-circuit target override. When `short_circuit_target` is `Some`,
+    /// the short-circuit jumps go to that block instead of the default
+    /// `after_block`, enabling jump threading to avoid redundant `__bool__` calls.
+    fn compile_bool_op_inner(
+        &mut self,
+        op: &ast::BoolOp,
+        values: &[ast::Expr],
+        short_circuit_target: Option<BlockIdx>,
+    ) -> CompileResult<()> {
+        let after_block = self.new_block();
+
+        let (last_value, values) = values.split_last().unwrap();
+
+        let target = short_circuit_target.unwrap_or(after_block);
+
+        for value in values {
+            self.compile_expression(value)?;
+
+            emit!(self, Instruction::Copy { index: 1_u32 });
+            match op {
+                ast::BoolOp::And => {
+                    emit!(
+                        self,
+                        Instruction::PopJumpIfFalse {
+                            target,
+                        }
+                    );
+                }
+                ast::BoolOp::Or => {
+                    emit!(
+                        self,
+                        Instruction::PopJumpIfTrue {
+                            target,
+                        }
+                    );
+                }
+            }
+
+            emit!(self, Instruction::PopTop);
+        }
+
+        // If all values did not qualify, take the value of the last value:
+        self.compile_expression(last_value)?;
+        self.switch_to_block(after_block);
+        Ok(())
+    }
+
     fn compile_dict(&mut self, items: &[ast::DictItem]) -> CompileResult<()> {
         let has_unpacking = items.iter().any(|item| item.key.is_none());
 
