Compiler parity: docstring dedent, StopIteration wrapper, constant folding

- Fix clean_doc to skip first line in margin calculation (match CPython)
- Add PEP 479 StopIteration handler to generator/coroutine bodies
  (SETUP_CLEANUP + CALL_INTRINSIC_1(StopIterationError) + RERAISE)
- Remove yield-from/await -1 depth compensation in RESUME DEPTH1
- Add constant condition elimination for if/while (if False, while True)
- Add POP_JUMP_IF_NONE/NOT_NONE for `x is None` patterns
- Add binary op constant folding (*, **, +, -, <<, >>, etc.)
- Add expr_constant() for compile-time boolean evaluation

Author: youknowone

crates/codegen/src/compile.rs

@@ -2360,43 +2360,7 @@ impl Compiler {
                 ..
             }) => {
                 self.enter_conditional_block();
-                match elif_else_clauses.as_slice() {
-                    // Only if
-                    [] => {
-                        let after_block = self.new_block();
-                        self.compile_jump_if(test, false, after_block)?;
-                        self.compile_statements(body)?;
-                        self.switch_to_block(after_block);
-                    }
-                    // If, elif*, elif/else
-                    [rest @ .., tail] => {
-                        let after_block = self.new_block();
-                        let mut next_block = self.new_block();
-
-                        self.compile_jump_if(test, false, next_block)?;
-                        self.compile_statements(body)?;
-                        emit!(self, PseudoInstruction::Jump { delta: after_block });
-
-                        for clause in rest {
-                            self.switch_to_block(next_block);
-                            next_block = self.new_block();
-                            if let Some(test) = &clause.test {
-                                self.compile_jump_if(test, false, next_block)?;
-                            } else {
-                                unreachable!() // must be elif
-                            }
-                            self.compile_statements(&clause.body)?;
-                            emit!(self, PseudoInstruction::Jump { delta: after_block });
-                        }
-
-                        self.switch_to_block(next_block);
-                        if let Some(test) = &tail.test {
-                            self.compile_jump_if(test, false, after_block)?;
-                        }
-                        self.compile_statements(&tail.body)?;
-                        self.switch_to_block(after_block);
-                    }
-                }
+                self.compile_if(test, body, elif_else_clauses)?;
                 self.leave_conditional_block();
             }
             ast::Stmt::While(ast::StmtWhile {
@@ -3899,6 +3863,22 @@ impl Compiler {
         // Set qualname
         self.set_qualname();
 
+        // PEP 479: Wrap generator/coroutine body with StopIteration handler
+        let is_gen = is_async || self.current_symbol_table().is_generator;
+        let stop_iteration_block = if is_gen {
+            let handler_block = self.new_block();
+            emit!(
+                self,
+                PseudoInstruction::SetupCleanup {
+                    delta: handler_block
+                }
+            );
+            self.push_fblock(FBlockType::StopIteration, handler_block, handler_block)?;
+            Some(handler_block)
+        } else {
+            None
+        };
+
         // Handle docstring - store in co_consts[0] if present
         let (doc_str, body) = split_doc(body, &self.opts);
         if let Some(doc) = &doc_str {
@@ -3929,6 +3909,20 @@ impl Compiler {
             self.arg_constant(ConstantData::None);
         }
 
+        // Close StopIteration handler and emit handler code
+        if let Some(handler_block) = stop_iteration_block {
+            emit!(self, PseudoInstruction::PopBlock);
+            self.pop_fblock(FBlockType::StopIteration);
+            self.switch_to_block(handler_block);
+            emit!(
+                self,
+                Instruction::CallIntrinsic1 {
+                    func: oparg::IntrinsicFunction1::StopIterationError
+                }
+            );
+            emit!(self, Instruction::Reraise { depth: 1u32 });
+        }
+
         // Exit scope and create function object
         let code = self.exit_scope();
         self.ctx = prev_ctx;
@@ -5182,6 +5176,84 @@ impl Compiler {
         self.store_name(name)
     }
 
+    /// Compile an if statement with constant condition elimination.
+    /// = compiler_if in CPython codegen.c
+    fn compile_if(
+        &mut self,
+        test: &ast::Expr,
+        body: &[ast::Stmt],
+        elif_else_clauses: &[ast::ElifElseClause],
+    ) -> CompileResult<()> {
+        let constant = Self::expr_constant(test);
+
+        // If the test is constant false, skip the body entirely
+        if constant == Some(false) {
+            // The NOP is emitted by CPython to keep line number info
+            self.emit_nop();
+            // Compile the elif/else chain (if any)
+            match elif_else_clauses {
+                [] => {} // nothing to do
+                [first, rest @ ..] => {
+                    if let Some(elif_test) = &first.test {
+                        // elif: recursively compile with elif as the new if
+                        self.compile_if(elif_test, &first.body, rest)?;
+                    } else {
+                        // else: compile the else body directly
+                        self.compile_statements(&first.body)?;
+                    }
+                }
+            }
+            return Ok(());
+        }
+
+        // If the test is constant true, compile body directly
+        if constant == Some(true) {
+            self.emit_nop();
+            self.compile_statements(body)?;
+            return Ok(());
+        }
+
+        // Non-constant test: normal compilation
+        match elif_else_clauses {
+            // Only if
+            [] => {
+                let after_block = self.new_block();
+                self.compile_jump_if(test, false, after_block)?;
+                self.compile_statements(body)?;
+                self.switch_to_block(after_block);
+            }
+            // If, elif*, elif/else
+            [rest @ .., tail] => {
+                let after_block = self.new_block();
+                let mut next_block = self.new_block();
+
+                self.compile_jump_if(test, false, next_block)?;
+                self.compile_statements(body)?;
+                emit!(self, PseudoInstruction::Jump { delta: after_block });
+
+                for clause in rest {
+                    self.switch_to_block(next_block);
+                    next_block = self.new_block();
+                    if let Some(test) = &clause.test {
+                        self.compile_jump_if(test, false, next_block)?;
+                    } else {
+                        unreachable!() // must be elif
+                    }
+                    self.compile_statements(&clause.body)?;
+                    emit!(self, PseudoInstruction::Jump { delta: after_block });
+                }
+
+                self.switch_to_block(next_block);
+                if let Some(test) = &tail.test {
+                    self.compile_jump_if(test, false, after_block)?;
+                }
+                self.compile_statements(&tail.body)?;
+                self.switch_to_block(after_block);
+            }
+        }
+        Ok(())
+    }
+
     fn compile_while(
         &mut self,
         test: &ast::Expr,
@@ -5190,27 +5262,37 @@ impl Compiler {
     ) -> CompileResult<()> {
         self.enter_conditional_block();
 
+        let constant = Self::expr_constant(test);
+
+        // while False: body → skip body, compile orelse only
+        if constant == Some(false) {
+            self.emit_nop();
+            self.compile_statements(orelse)?;
+            self.leave_conditional_block();
+            return Ok(());
+        }
+
         let while_block = self.new_block();
         let else_block = self.new_block();
         let after_block = self.new_block();
 
-        // Note: SetupLoop is no longer emitted (break/continue use direct jumps)
         self.switch_to_block(while_block);
-
-        // Push fblock for while loop
         self.push_fblock(FBlockType::WhileLoop, while_block, after_block)?;
 
-        self.compile_jump_if(test, false, else_block)?;
+        // while True: → no condition test, just NOP
+        if constant == Some(true) {
+            self.emit_nop();
+        } else {
+            self.compile_jump_if(test, false, else_block)?;
+        }
 
         let was_in_loop = self.ctx.loop_data.replace((while_block, after_block));
         self.compile_statements(body)?;
         self.ctx.loop_data = was_in_loop;
         emit!(self, PseudoInstruction::Jump { delta: while_block });
         self.switch_to_block(else_block);
 
-        // Pop fblock
         self.pop_fblock(FBlockType::WhileLoop);
-        // Note: PopBlock is no longer emitted for loops
         self.compile_statements(orelse)?;
         self.switch_to_block(after_block);
 
@@ -6998,6 +7080,40 @@ impl Compiler {
             }) => {
                 self.compile_jump_if(operand, !condition, target_block)?;
             }
+            // `x is None` / `x is not None` → POP_JUMP_IF_NONE / POP_JUMP_IF_NOT_NONE
+            ast::Expr::Compare(ast::ExprCompare {
+                left,
+                ops,
+                comparators,
+                ..
+            }) if ops.len() == 1
+                && matches!(ops[0], ast::CmpOp::Is | ast::CmpOp::IsNot)
+                && comparators.len() == 1
+                && matches!(&comparators[0], ast::Expr::NoneLiteral(_)) =>
+            {
+                self.compile_expression(left)?;
+                let is_not = matches!(ops[0], ast::CmpOp::IsNot);
+                // is None + jump_if_false → POP_JUMP_IF_NOT_NONE
+                // is None + jump_if_true → POP_JUMP_IF_NONE
+                // is not None + jump_if_false → POP_JUMP_IF_NONE
+                // is not None + jump_if_true → POP_JUMP_IF_NOT_NONE
+                let jump_if_none = condition != is_not;
+                if jump_if_none {
+                    emit!(
+                        self,
+                        Instruction::PopJumpIfNone {
+                            delta: target_block,
+                        }
+                    );
+                } else {
+                    emit!(
+                        self,
+                        Instruction::PopJumpIfNotNone {
+                            delta: target_block,
+                        }
+                    );
+                }
+            }
             _ => {
                 // Fall back case which always will work!
                 self.compile_expression(expression)?;
@@ -8801,6 +8917,38 @@ impl Compiler {
         self.code_stack.last_mut().expect("no code on stack")
     }
 
+    /// Evaluate whether an expression is a compile-time constant boolean.
+    /// Returns Some(true) for truthy constants, Some(false) for falsy constants,
+    /// None for non-constant expressions.
+    /// = expr_constant in CPython compile.c
+    fn expr_constant(expr: &ast::Expr) -> Option<bool> {
+        match expr {
+            ast::Expr::BooleanLiteral(ast::ExprBooleanLiteral { value, .. }) => Some(*value),
+            ast::Expr::NoneLiteral(_) => Some(false),
+            ast::Expr::EllipsisLiteral(_) => Some(true),
+            ast::Expr::NumberLiteral(ast::ExprNumberLiteral { value, .. }) => match value {
+                ast::Number::Int(i) => {
+                    let n: i64 = i.as_i64().unwrap_or(1);
+                    Some(n != 0)
+                }
+                ast::Number::Float(f) => Some(*f != 0.0),
+                ast::Number::Complex { real, imag, .. } => Some(*real != 0.0 || *imag != 0.0),
+            },
+            ast::Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
+                Some(!value.to_str().is_empty())
+            }
+            ast::Expr::BytesLiteral(ast::ExprBytesLiteral { value, .. }) => {
+                Some(value.bytes().next().is_some())
+            }
+            ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => Some(!elts.is_empty()),
+            _ => None,
+        }
+    }
+
+    fn emit_nop(&mut self) {
+        emit!(self, Instruction::Nop);
+    }
+
     /// Enter a conditional block (if/for/while/match/try/with)
     /// PEP 649: Track conditional annotation context
     fn enter_conditional_block(&mut self) {
@@ -9411,32 +9559,34 @@ impl EmitArg<bytecode::Label> for BlockIdx {
 // = _PyCompile_CleanDoc
 fn clean_doc(doc: &str) -> String {
     let doc = expandtabs(doc, 8);
-    // First pass: find minimum indentation of any non-blank lines
-    // after first line.
+    // First pass: find minimum indentation of non-blank lines AFTER the first line.
+    // A "blank line" is one containing only spaces (or empty).
     let margin = doc
-        .lines()
-        // Find the non-blank lines
-        .filter(|line| !line.trim().is_empty())
-        // get the one with the least indentation
-        .map(|line| line.chars().take_while(|c| c == &' ').count())
-        .min();
-    if let Some(margin) = margin {
-        let mut cleaned = String::with_capacity(doc.len());
-        // copy first line without leading whitespace
-        if let Some(first_line) = doc.lines().next() {
-            cleaned.push_str(first_line.trim_start());
-        }
-        // copy subsequent lines without margin.
-        for line in doc.split('\n').skip(1) {
-            cleaned.push('\n');
-            let cleaned_line = line.chars().skip(margin).collect::<String>();
-            cleaned.push_str(&cleaned_line);
-        }
-
-        cleaned
-    } else {
-        doc.to_owned()
-    }
+        .split('\n')
+        .skip(1) // skip first line
+        .filter(|line| line.chars().any(|c| c != ' ')) // non-blank lines only
+        .map(|line| line.chars().take_while(|c| *c == ' ').count())
+        .min()
+        .unwrap_or(0);
+
+    let mut cleaned = String::with_capacity(doc.len());
+    // Strip all leading spaces from the first line
+    if let Some(first_line) = doc.split('\n').next() {
+        let trimmed = first_line.trim_start();
+        // Early exit: no leading spaces on first line AND margin == 0
+        if trimmed.len() == first_line.len() && margin == 0 {
+            return doc.to_owned();
+        }
+        cleaned.push_str(trimmed);
+    }
+    // Subsequent lines: skip up to `margin` leading spaces
+    for line in doc.split('\n').skip(1) {
+        cleaned.push('\n');
+        let skip = line.chars().take(margin).take_while(|c| *c == ' ').count();
+        cleaned.push_str(&line[skip..]);
+    }
+
+    cleaned
 }
 
 // copied from rustpython_common::str, so we don't have to depend on it just for this function