depyo 1.0.1 → 1.0.3

package/lib/handlers/control_flow_jumps.js

@@ -23,6 +23,179 @@ function findBackwardJump(code, startIndex, currentOffset, backJumpOpcodes) {
     return null;
 }
 
+// Detect a Py2.x (or early-Py3) boolean expression chain rooted at the current
+// JUMP_IF_* instruction. An expression chain converges at a value consumer
+// (STORE_*, RETURN_*, COMPARE_OP, BINARY_*, UNARY_*, CALL_*, POP_JUMP_IF_*,
+// another JUMP_IF_* for nested chains) without crossing block-level opcodes.
+// This distinguishes `a = b and c or d` (expression, consumer=STORE_NAME) from
+// `if b: pass; if c: pass` (control flow, two separate If blocks).
+function isBoolExprChain(ctx) {
+    const OpCodes = ctx.OpCodes;
+    const chainJumpOps = new Set([
+        OpCodes.JUMP_IF_FALSE_A,
+        OpCodes.JUMP_IF_TRUE_A,
+        OpCodes.JUMP_IF_FALSE_OR_POP_A,
+        OpCodes.JUMP_IF_TRUE_OR_POP_A
+    ].filter(v => v !== undefined));
+    const valueOps = new Set([
+        OpCodes.LOAD_NAME_A, OpCodes.LOAD_FAST_A, OpCodes.LOAD_CONST_A,
+        OpCodes.LOAD_GLOBAL_A, OpCodes.LOAD_ATTR_A, OpCodes.LOAD_DEREF_A,
+        OpCodes.LOAD_CLASSDEREF_A, OpCodes.LOAD_CLOSURE_A,
+        OpCodes.LOAD_FAST_CHECK_A, OpCodes.LOAD_FAST_AND_CLEAR_A,
+        OpCodes.LOAD_FAST_LOAD_FAST_A,
+        OpCodes.LOAD_LOCALS, OpCodes.LOAD_BUILD_CLASS,
+        OpCodes.POP_TOP, OpCodes.POP_TOP_A,
+        OpCodes.DUP_TOP, OpCodes.DUP_TOP_A, OpCodes.ROT_TWO, OpCodes.ROT_THREE, OpCodes.ROT_FOUR,
+        OpCodes.COPY_A, OpCodes.SWAP_A,
+        OpCodes.COMPARE_OP, OpCodes.COMPARE_OP_A,
+        OpCodes.UNARY_POSITIVE, OpCodes.UNARY_NEGATIVE, OpCodes.UNARY_NOT, OpCodes.UNARY_INVERT, OpCodes.UNARY_CONVERT,
+        OpCodes.BINARY_ADD, OpCodes.BINARY_SUBTRACT, OpCodes.BINARY_MULTIPLY, OpCodes.BINARY_DIVIDE,
+        OpCodes.BINARY_TRUE_DIVIDE, OpCodes.BINARY_FLOOR_DIVIDE, OpCodes.BINARY_MODULO, OpCodes.BINARY_POWER,
+        OpCodes.BINARY_LSHIFT, OpCodes.BINARY_RSHIFT, OpCodes.BINARY_AND, OpCodes.BINARY_OR, OpCodes.BINARY_XOR,
+        OpCodes.BINARY_SUBSCR, OpCodes.BINARY_SUBSCR_A,
+        OpCodes.BINARY_OP_A, OpCodes.BINARY_OP,
+        OpCodes.BINARY_MATRIX_MULTIPLY,
+        OpCodes.IS_OP_A, OpCodes.CONTAINS_OP_A
+    ].filter(v => v !== undefined));
+    const consumerOps = new Set([
+        OpCodes.STORE_NAME_A, OpCodes.STORE_FAST_A, OpCodes.STORE_GLOBAL_A,
+        OpCodes.STORE_DEREF_A, OpCodes.STORE_ATTR_A,
+        OpCodes.STORE_SUBSCR, OpCodes.STORE_SUBSCR_A,
+        OpCodes.RETURN_VALUE, OpCodes.RETURN_VALUE_A, OpCodes.RETURN_CONST_A,
+        OpCodes.POP_JUMP_IF_FALSE_A, OpCodes.POP_JUMP_IF_TRUE_A,
+        OpCodes.POP_JUMP_FORWARD_IF_FALSE_A, OpCodes.POP_JUMP_FORWARD_IF_TRUE_A,
+        OpCodes.POP_JUMP_FORWARD_IF_NONE_A, OpCodes.POP_JUMP_FORWARD_IF_NOT_NONE_A,
+        OpCodes.POP_JUMP_BACKWARD_IF_NONE_A, OpCodes.POP_JUMP_BACKWARD_IF_NOT_NONE_A,
+        OpCodes.POP_JUMP_IF_NONE_A, OpCodes.POP_JUMP_IF_NOT_NONE_A,
+        OpCodes.CALL_FUNCTION_A, OpCodes.CALL_FUNCTION_KW_A, OpCodes.CALL_FUNCTION_EX_A,
+        OpCodes.CALL_A, OpCodes.CALL_KW_A, OpCodes.CALL_METHOD_A,
+        OpCodes.PRINT_ITEM, OpCodes.PRINT_ITEM_TO, OpCodes.PRINT_EXPR
+    ].filter(v => v !== undefined));
+
+    const startIdx = ctx.code.CurrentInstructionIndex;
+    const instructions = ctx.code.Instructions || [];
+    if (!instructions[startIdx] || !chainJumpOps.has(instructions[startIdx].OpCodeID)) return false;
+
+    let maxTarget = instructions[startIdx].JumpTarget;
+    if (!maxTarget || maxTarget <= instructions[startIdx].Offset) return false;
+
+    const maxLookahead = 64;
+    for (let i = startIdx + 1; i < instructions.length && i - startIdx <= maxLookahead; i++) {
+        const instr = instructions[i];
+        if (!instr) return false;
+        // Reached convergence offset — inspect what's there
+        if (instr.Offset >= maxTarget) {
+            // Another JUMP_IF_* at the convergence → nested chain continuation
+            if (chainJumpOps.has(instr.OpCodeID)) return true;
+            if (consumerOps.has(instr.OpCodeID)) return true;
+            // POP_TOP at convergence = control flow cleanup (if-body), not expression.
+            // Excluding this keeps `if X and Y: pass` — which always ends at POP_TOP —
+            // on the existing if-merge path and lets frame synthesis fire only when
+            // the chain value is actually consumed (STORE_*, RETURN_*, CALL_*, etc.).
+            if (instr.OpCodeID === OpCodes.POP_TOP || instr.OpCodeID === OpCodes.POP_TOP_A) return false;
+            // Any value op at the convergence means expression continues
+            // (e.g. chain is sub-expression of a larger one)
+            if (valueOps.has(instr.OpCodeID)) return true;
+            return false;
+        }
+        // Extend the chain by further JUMP_IF_* targets
+        if (chainJumpOps.has(instr.OpCodeID)) {
+            if (instr.JumpTarget > maxTarget) {
+                maxTarget = instr.JumpTarget;
+            }
+            continue;
+        }
+        // Only value-level opcodes allowed inside the chain window
+        if (!valueOps.has(instr.OpCodeID)) return false;
+    }
+    return false;
+}
+
+// Frame-based reconstruction of Py2.x (and early-Py3) boolean expression chains.
+// A chain of `LOAD + JUMP_IF_FALSE/TRUE + POP_TOP` pairs converging at a value
+// consumer (STORE/RETURN/CALL/...) is the bytecode shape of `a = b and c or d`
+// style expressions. The `isBoolExprChain` detector gates this; here we grow a
+// per-decompiler stack of frames {target, op, lhs} and fold them into a
+// compound AST.ASTBinary when execution reaches each frame's target offset.
+//
+// JUMP_IF_FALSE + POP_TOP => AND (lhs short-circuits when falsy).
+// JUMP_IF_TRUE  + POP_TOP => OR  (lhs short-circuits when truthy).
+function resolveBoolChainFrames(ctx, atOffset) {
+    if (!ctx.boolChainStack || ctx.boolChainStack.length === 0) return;
+    while (ctx.boolChainStack.length > 0) {
+        const frame = ctx.boolChainStack[ctx.boolChainStack.length - 1];
+        if (frame.target > atOffset) break;
+        ctx.boolChainStack.pop();
+        if (ctx.dataStack.length === 0) {
+            // Stack underflow means we misread the chain; drop remaining frames
+            // so we don't synthesize garbage and let normal handling resume.
+            ctx.boolChainStack = [];
+            return;
+        }
+        const rhs = ctx.dataStack.pop();
+        const op = frame.op === 'AND'
+            ? AST.ASTBinary.BinOp.LogicalAnd
+            : AST.ASTBinary.BinOp.LogicalOr;
+        const combined = new AST.ASTBinary(frame.lhs, rhs, op);
+        combined.line = ctx.code.Current?.LineNo ?? 0;
+        ctx.dataStack.push(combined);
+    }
+}
+
+function tryStartBoolChain(ctx) {
+    const OpCodes = ctx.OpCodes;
+    // Only Py2.x peek-and-branch (JUMP_IF_FALSE_A / JUMP_IF_TRUE_A + POP_TOP).
+    // The _OR_POP variants are already reconstructed correctly by the
+    // existing 3.x handler; intercepting them here would double-wrap.
+    const peekJumps = [OpCodes.JUMP_IF_FALSE_A, OpCodes.JUMP_IF_TRUE_A]
+        .filter(v => v !== undefined);
+    if (!peekJumps.includes(ctx.code.Current.OpCodeID)) return false;
+    if (ctx.inMatchPattern) return false;
+    if (ctx.dataStack.length === 0) return false;
+    if (!isBoolExprChain(ctx)) return false;
+
+    const rawTarget = ctx.code.Current.JumpTarget;
+    if (!rawTarget || rawTarget <= ctx.code.Current.Offset) return false;
+
+    const isFalseJump = ctx.code.Current.OpCodeID === OpCodes.JUMP_IF_FALSE_A;
+
+    // Py2.4+ optimization: the outer JUMP_IF_* may target a shared POP_TOP
+    // that also serves as the inner chain's fall-through sink (merged
+    // false-branch entry). In that case raw target points past an inner
+    // JUMP_IF_*, which would nest the inner chain under the outer frame —
+    // wrong parse. Re-aim the frame at the inner JUMP_IF_* offset so the
+    // outer resolves BEFORE the inner pushes its own frame.
+    // Shape: <outer JUMP_IF> ... POP_TOP <LOADs>* <inner JUMP_IF> POP_TOP@rawTarget <LOADs>* <consumer>.
+    let target = rawTarget;
+    const instructions = ctx.code.Instructions || [];
+    const curIdx = ctx.code.CurrentInstructionIndex;
+    const chainJumpOps = new Set([
+        OpCodes.JUMP_IF_FALSE_A, OpCodes.JUMP_IF_TRUE_A
+    ].filter(v => v !== undefined));
+    const popOps = new Set([OpCodes.POP_TOP, OpCodes.POP_TOP_A].filter(v => v !== undefined));
+    const rawTargetIdx = instructions.findIndex(i => i && i.Offset === rawTarget);
+    if (rawTargetIdx > curIdx + 1 &&
+        popOps.has(instructions[rawTargetIdx]?.OpCodeID)) {
+        for (let i = rawTargetIdx - 1; i > curIdx; i--) {
+            const instr = instructions[i];
+            if (!instr) break;
+            if (chainJumpOps.has(instr.OpCodeID) && instr.JumpTarget >= rawTarget) {
+                target = instr.Offset;
+                break;
+            }
+        }
+    }
+
+    const lhs = ctx.dataStack.pop();
+    ctx.boolChainStack = ctx.boolChainStack || [];
+    ctx.boolChainStack.push({ target, op: isFalseJump ? 'AND' : 'OR', lhs });
+
+    if (ctx.code.Next?.OpCodeID === OpCodes.POP_TOP) {
+        ctx.code.GoNext();
+    }
+    return true;
+}
+
 function tryStartConditionalExpression(ctx, cond, falseOffset) {
     if (!cond || falseOffset <= ctx.code.Current.Offset) {
         return false;
@@ -32,13 +205,53 @@ function tryStartConditionalExpression(ctx, cond, falseOffset) {
         return false;
     }
 
+    // Statement terminators inside the true-branch: if the branch ends with a
+    // side-effecting instruction (STORE_*, POP_TOP, RETURN, RAISE) before the
+    // candidate JUMP_FORWARD, this is an if/else, not a ternary, and we must
+    // not push a pending — that would suppress the real If block.
+    const storeOps = new Set([
+        ctx.OpCodes.STORE_FAST_A,
+        ctx.OpCodes.STORE_NAME_A,
+        ctx.OpCodes.STORE_GLOBAL_A,
+        ctx.OpCodes.STORE_DEREF_A,
+        ctx.OpCodes.STORE_ATTR_A,
+        ctx.OpCodes.STORE_SUBSCR,
+        ctx.OpCodes.STORE_SUBSCR_A,
+        ctx.OpCodes.POP_TOP,
+        ctx.OpCodes.POP_TOP_A,
+        ctx.OpCodes.RETURN_VALUE,
+        ctx.OpCodes.RETURN_VALUE_A,
+        ctx.OpCodes.RETURN_CONST_A,
+        ctx.OpCodes.RAISE_VARARGS_A,
+    ].filter(v => v !== undefined));
+    const blockOpeners = new Set([
+        ctx.OpCodes.SETUP_EXCEPT_A,
+        ctx.OpCodes.SETUP_FINALLY_A,
+        ctx.OpCodes.SETUP_LOOP_A,
+        ctx.OpCodes.SETUP_WITH_A,
+        ctx.OpCodes.SETUP_ASYNC_WITH_A,
+        ctx.OpCodes.FOR_ITER_A,
+    ].filter(v => v !== undefined));
+
     let joinInstr = null;
     for (let i = ctx.code.CurrentInstructionIndex + 1; i < falseIdx; i++) {
         const instr = ctx.code.Instructions[i];
         if (!instr) {
             continue;
         }
+        // Crossing a block opener disqualifies: the JUMP_FORWARD inside the
+        // nested block is not the true-branch's join.
+        if (blockOpeners.has(instr.OpCodeID)) {
+            return false;
+        }
         if ([ctx.OpCodes.JUMP_FORWARD_A, ctx.OpCodes.JUMP_ABSOLUTE_A].includes(instr.OpCodeID)) {
+            // Look at the instruction immediately before the jump. For a ternary,
+            // it should leave a value on the stack (LOAD_*, BUILD_*, arithmetic),
+            // not be a statement terminator.
+            const prev = ctx.code.Instructions[i - 1];
+            if (prev && storeOps.has(prev.OpCodeID)) {
+                return false;
+            }
             const target = instr.JumpTarget ?? -1;
             if (target > falseOffset && target <= falseOffset + 50) {
                 joinInstr = instr;
@@ -71,6 +284,33 @@ function captureTrueBranchForConditional(ctx) {
     if (!pending) {
         return false;
     }
+    // A real ternary leaves the true-branch expression on the data stack; if
+    // the stack is empty, this JUMP_FORWARD belongs to some other structure
+    // (e.g. a nested try/except whose exit jump happens to land on the same
+    // offset) and we must not consume it.
+    if (!ctx.dataStack.length) {
+        return false;
+    }
+    // Block openers between pending.startOffset and here mean the JUMP_FORWARD
+    // is inside a nested scope and cannot be the ternary's true branch.
+    const blockOpeners = new Set([
+        ctx.OpCodes.SETUP_EXCEPT_A,
+        ctx.OpCodes.SETUP_FINALLY_A,
+        ctx.OpCodes.SETUP_LOOP_A,
+        ctx.OpCodes.SETUP_WITH_A,
+        ctx.OpCodes.SETUP_ASYNC_WITH_A,
+        ctx.OpCodes.FOR_ITER_A,
+    ].filter(v => v !== undefined));
+    const startIdx = ctx.code.GetIndexByOffset(pending.startOffset);
+    const curIdx = ctx.code.CurrentInstructionIndex;
+    if (startIdx >= 0) {
+        for (let i = startIdx + 1; i < curIdx; i++) {
+            const instr = ctx.code.Instructions[i];
+            if (instr && blockOpeners.has(instr.OpCodeID)) {
+                return false;
+            }
+        }
+    }
     pending.trueValue = ctx.dataStack.pop();
     return true;
 }
@@ -156,6 +396,15 @@ function processJumpOps() {
         return;
     }
 
+    // Intercept boolean expression chains (a = b and c or d style) before the
+    // If-block machinery. If this JUMP_IF_* is part of a chain converging at a
+    // value consumer, push a frame and let resolveBoolChainFrames fold the
+    // combined expression back onto dataStack when the chain's target offset
+    // is reached. See comments on tryStartBoolChain / resolveBoolChainFrames.
+    if (tryStartBoolChain(this)) {
+        return;
+    }
+
     const wrapNoneComparison = (expectNone) => {
         let value = this.dataStack.pop();
         let cmp = new AST.ASTCompare(
@@ -213,8 +462,29 @@ function processJumpOps() {
     }
 
     // CRITICAL: Close blocks that have ended before creating new conditional block
-    // This ensures proper sibling relationships between if/elif blocks
-    while (this.curBlock.end > 0 &&
+    // This ensures proper sibling relationships between if/elif blocks.
+    //
+    // Exception: a Py2.x boolean expression chain (`a = b and c or d`) compiles
+    // to a sequence of JUMP_IF_FALSE/JUMP_IF_TRUE + POP_TOP pairs converging at
+    // a consumer (STORE/RETURN/CALL/etc). The first JUMP_IF_* opens an empty
+    // If(end=T) block; when we reach offset T we find another JUMP_IF_* that
+    // should continue the chain via the AND/OR merge below (line ~540). If we
+    // close here, the merge opportunity is lost and the expression renders as
+    // stray `if X: pass` control flow.
+    const chainJumpOps = [
+        this.OpCodes.JUMP_IF_FALSE_A,
+        this.OpCodes.JUMP_IF_TRUE_A,
+        this.OpCodes.JUMP_IF_FALSE_OR_POP_A,
+        this.OpCodes.JUMP_IF_TRUE_OR_POP_A
+    ].filter(v => v !== undefined);
+    const keepOpenForChain = chainJumpOps.includes(this.code.Current.OpCodeID) &&
+        this.curBlock.size === 0 &&
+        this.curBlock.end === this.code.Current.Offset &&
+        [AST.ASTBlock.BlockType.If, AST.ASTBlock.BlockType.Elif, AST.ASTBlock.BlockType.While].includes(this.curBlock.blockType) &&
+        isBoolExprChain(this);
+
+    while (!keepOpenForChain &&
+           this.curBlock.end > 0 &&
            this.curBlock.end <= this.code.Current.Offset &&
            this.curBlock.blockType != AST.ASTBlock.BlockType.Main &&
            this.blocks.length > 1) {
@@ -339,9 +609,19 @@ function processJumpOps() {
         }
     }
 
+    const isEgMatchCall = cond instanceof AST.ASTCall &&
+        cond.func instanceof AST.ASTName &&
+        cond.func.name === "__check_eg_match__";
+    const isExceptCompare = cond instanceof AST.ASTCompare &&
+        cond.op == AST.ASTCompare.CompareOp.Exception;
+
     // Conditional expression (a if cond else b) heuristic:
     // POP_JUMP_IF_* to falseOffset, then JUMP_FORWARD to joinOffset > falseOffset.
+    // Skip for exception matches: except handlers emit a similar bytecode shape
+    // (POP_JUMP_IF_FALSE past handler body, JUMP_FORWARD over END_FINALLY) but
+    // are not ternary expressions and must not be rewritten.
     if (!this.inMatchPattern &&
+        !isExceptCompare && !isEgMatchCall &&
         condJumpOpcodes.has(this.code.Current.OpCodeID) &&
         tryStartConditionalExpression(this, cond, rawJumpTarget)) {
         return;
@@ -362,12 +642,6 @@ function processJumpOps() {
         }
     }
 
-    const isEgMatchCall = cond instanceof AST.ASTCall &&
-        cond.func instanceof AST.ASTName &&
-        cond.func.name === "__check_eg_match__";
-    const isExceptCompare = cond instanceof AST.ASTCompare &&
-        cond.op == AST.ASTCompare.CompareOp.Exception;
-
     if (isExceptCompare || isEgMatchCall) {
         if (global.g_cliArgs?.debug) {
             const matchType = isExceptCompare ? cond.right : cond.pparams?.[1];
@@ -377,13 +651,15 @@ function processJumpOps() {
         const handlerEnd = this.findExceptionHandlerEnd ? this.findExceptionHandlerEnd(this.code.Current.Offset) : null;
         if (this.curBlock.blockType == AST.ASTBlock.BlockType.Except
                 && this.curBlock.condition == null) {
-            // Reuse current except block (from exception table) instead of creating a nested one
+            // Reuse current except block (from exception table or pushed by JUMP_FORWARD)
+            // instead of creating a nested one. Return immediately to avoid the
+            // fall-through that would otherwise create a stray If block on top.
             this.curBlock.condition = isExceptCompare ? cond.right : cond.pparams?.[1];
             if (handlerEnd) {
                 this.curBlock.end = handlerEnd;
             }
             this.curBlock.init();
-            ifblk = null; // no extra push
+            return;
         } else {
             const end = handlerEnd || offs;
             const matchType = isExceptCompare ? cond.right : cond.pparams?.[1];
@@ -398,10 +674,26 @@ function processJumpOps() {
             }
         }
 
-        if (this.curBlock.size == 0 ||
-            (this.curBlock.size == 1 &&
-             this.curBlock.nodes[0] instanceof AST.ASTCondBlock &&
-             this.curBlock.nodes[0].blockType == AST.ASTBlock.BlockType.If)) {
+        // Only collapse else→elif when the Else attaches to an If/Elif.
+        // `while/for ... else: if X: ...` must stay as a nested if, since
+        // rendering `elif` after `while/for` is invalid Python. The Else's
+        // prior sibling (last node in the enclosing block) reveals what
+        // the Else was created for.
+        let elseHolder = this.blocks.length >= 2
+            ? this.blocks[this.blocks.length - 2]
+            : null;
+        let priorSibling = elseHolder && elseHolder.size > 0
+            ? elseHolder.nodes[elseHolder.size - 1]
+            : null;
+        let elseAttachesToIf = priorSibling instanceof AST.ASTCondBlock &&
+            (priorSibling.blockType == AST.ASTBlock.BlockType.If ||
+             priorSibling.blockType == AST.ASTBlock.BlockType.Elif);
+
+        if (elseAttachesToIf &&
+            (this.curBlock.size == 0 ||
+             (this.curBlock.size == 1 &&
+              this.curBlock.nodes[0] instanceof AST.ASTCondBlock &&
+              this.curBlock.nodes[0].blockType == AST.ASTBlock.BlockType.If))) {
             /* Collapse into elif statement */
             if (global.g_cliArgs?.debug) {
                 console.log(`ELIF DETECTED: else block size=${this.curBlock.size}, converting to elif at offset ${this.code.Current.Offset}`);
@@ -462,7 +754,12 @@ function processJumpOps() {
                 && this.curBlock.comprehension
                 && this.object.Reader.versionCompare(2, 7) >= 0) {
         /* Comprehension condition */
-        this.curBlock.condition = cond;
+        let actualCond = cond;
+        if (neg) {
+            actualCond = new AST.ASTUnary(cond, AST.ASTUnary.UnaryOp.Not);
+            actualCond.line = this.code.Current.LineNo;
+        }
+        this.curBlock.condition = actualCond;
         return;
     }
 
@@ -493,10 +790,21 @@ function processJumpOps() {
                      lastNode.blockType == AST.ASTBlock.BlockType.Elif) &&
                     !lastNodeInStack) {  // CLOSED, not in stack = sibling!
 
-                    shouldBeElif = true;
+                    // Assert-style guards (`if not X: raise`) don't chain as elif.
+                    // `assert X; assert Y` and `if not X: raise; if not Y: raise`
+                    // share bytecode shape with elif, but rendering the second as
+                    // elif creates an orphan `elif` after the first becomes `assert`.
+                    let priorIsAssertGuard =
+                        lastNode.negative &&
+                        lastNode.nodes.length == 1 &&
+                        lastNode.nodes[0] instanceof AST.ASTRaise;
 
-                    if (global.g_cliArgs?.debug) {
-                        console.log(`ELIF DETECTED: Creating elif at offset ${this.code.Current.Offset} (follows ${lastNode.type_str} at ${lastNode.start})`);
+                    if (!priorIsAssertGuard) {
+                        shouldBeElif = true;
+
+                        if (global.g_cliArgs?.debug) {
+                            console.log(`ELIF DETECTED: Creating elif at offset ${this.code.Current.Offset} (follows ${lastNode.type_str} at ${lastNode.start})`);
+                        }
                     }
                 }
             }
@@ -552,6 +860,37 @@ function handleJumpAbsoluteA() {
 
     // [offs] = this.code.FindEndOfBlock(offs);
 
+    // Inside a try-inside-loop (e.g. `while x: try: ... except: ...`),
+    // the successful-path jump back to the loop is emitted as JUMP_ABSOLUTE
+    // instead of JUMP_FORWARD. If we don't open the Except block here, the
+    // handler body ends up appended to the container as raw statements and
+    // the `__exception__` placeholder leaks into the output.
+    if (this.curBlock.blockType == AST.ASTBlock.BlockType.Container) {
+        let cont = this.curBlock;
+        if (cont.hasExcept && this.code.Next?.Offset <= cont.except) {
+            // Find the END_FINALLY that closes this except so the handler body
+            // stays attached to the Except block rather than leaking back into
+            // the Container.
+            let handlerEnd = cont.except;
+            let cursor = cont.except;
+            for (let i = 0; i < 200; i++) {
+                const instr = this.code.PeekInstructionAtOffset(cursor);
+                if (!instr) break;
+                if (instr.OpCodeID === this.OpCodes.END_FINALLY) {
+                    handlerEnd = instr.Offset;
+                    break;
+                }
+                cursor = instr.Offset + (instr.Size || 3);
+            }
+            cont.end = handlerEnd;
+            let except = new AST.ASTCondBlock(AST.ASTBlock.BlockType.Except, this.code.Current.Offset, handlerEnd, null, false);
+            except.init();
+            this.blocks.push(except);
+            this.curBlock = this.blocks.top();
+            return;
+        }
+    }
+
     if (offs <= this.code.Next?.Offset) {
         if (this.curBlock.blockType == AST.ASTBlock.BlockType.For) {
             let is_jump_to_start = offs == this.curBlock.start;
@@ -564,11 +903,63 @@ function handleJumpAbsoluteA() {
                 let top = this.dataStack.top();
 
                 if (top instanceof AST.ASTComprehension) {
-                    let comp = this.dataStack.pop();            
-                    comp.addGenerator(this.curBlock);
+                    top.addGenerator(this.curBlock);
                     this.blocks.pop();
                     this.curBlock = this.blocks.top();
-                    this.curBlock.append(comp);
+                    // For multi-clause comprehensions/genexprs, keep the
+                    // ASTComprehension on the data stack so the enclosing
+                    // For+comprehension block can attach its own generator.
+                    // Only materialize it as a statement once we're clear of
+                    // comprehension-tagged for-blocks.
+                    if (!(this.curBlock.blockType == AST.ASTBlock.BlockType.For && this.curBlock.comprehension)) {
+                        // Detect bare listcomp statement vs assignment/return.
+                        // Bare form ends with POP_TOP (possibly after DELETE_FAST/
+                        // DELETE_NAME that drops the cached `_[N]`). If POP_TOP
+                        // is the terminator, materialize the comprehension as a
+                        // statement; otherwise leave it on the stack so the
+                        // downstream consumer (STORE_NAME, RETURN_VALUE, CALL,
+                        // BINARY_*, …) can use it as an expression.
+                        // Generator expressions always materialize as the sole
+                        // body statement so the enclosing CALL handler can
+                        // extract the comp from the <genexpr> code object.
+                        let isBareStatement = top.kind === AST.ASTComprehension.GENERATOR;
+                        if (!isBareStatement && this.code.PeekInstructionAtOffset) {
+                            let scanOff = this.code.Next?.Offset;
+                            const SKIP_OPS = [
+                                this.OpCodes.DELETE_FAST_A,
+                                this.OpCodes.DELETE_NAME_A,
+                                this.OpCodes.DELETE_GLOBAL_A,
+                                this.OpCodes.DELETE_DEREF_A,
+                                this.OpCodes.JUMP_ABSOLUTE_A,
+                                this.OpCodes.JUMP_FORWARD_A
+                            ];
+                            for (let i = 0; i < 12 && scanOff != null; i++) {
+                                const ins = this.code.PeekInstructionAtOffset(scanOff);
+                                if (!ins) break;
+                                if (SKIP_OPS.includes(ins.OpCodeID)) {
+                                    scanOff = ins.Offset + (ins.Size || 3);
+                                    continue;
+                                }
+                                if (ins.OpCodeID == this.OpCodes.POP_TOP) {
+                                    // Distinguish real bare-listcomp marker
+                                    // from intra-loop skip-path POP_TOP in
+                                    // 2.x (which is always followed by a
+                                    // JUMP_ABSOLUTE back to FOR_ITER).
+                                    const nextIns = this.code.PeekInstructionAtOffset(ins.Offset + (ins.Size || 1));
+                                    if (nextIns && SKIP_OPS.includes(nextIns.OpCodeID)) {
+                                        scanOff = ins.Offset + (ins.Size || 1);
+                                        continue;
+                                    }
+                                    isBareStatement = true;
+                                }
+                                break;
+                            }
+                        }
+                        if (isBareStatement) {
+                            let comp = this.dataStack.pop();
+                            this.curBlock.append(comp);
+                        }
+                    }
                 } else {
                     let tmp = this.curBlock;
                     this.blocks.pop();
@@ -590,6 +981,74 @@ function handleJumpAbsoluteA() {
                 this.blocks.top().append(this.curBlock);
                 this.curBlock = this.blocks.top();
             }
+        } else if (this.curBlock.blockType == AST.ASTBlock.BlockType.Except
+                && this.code.PeekInstructionAtOffset
+                && ![this.OpCodes.JUMP_ABSOLUTE_A, this.OpCodes.JUMP_FORWARD_A].includes(this.code.Prev?.OpCodeID)
+                && this.blocks.length >= 2
+                && this.blocks[this.blocks.length - 2].blockType == AST.ASTBlock.BlockType.Container) {
+            // Python 2.x try/except/else inside a loop: the except handler
+            // body ends with JUMP_ABSOLUTE back to the loop start (skipping
+            // the else body). Bytecode then has POP_TOP + END_FINALLY + else
+            // body, and the else body itself ends with another JUMP_ABSOLUTE
+            // to the same loop start. Without this branch, the else body
+            // gets attached to the surrounding loop instead of the try.
+            let endFinallyAhead = false;
+            let scan = this.code.Next?.Offset;
+            for (let i = 0; i < 4 && scan != null; i++) {
+                const instr = this.code.PeekInstructionAtOffset(scan);
+                if (!instr) break;
+                if (instr.OpCodeID === this.OpCodes.END_FINALLY) {
+                    endFinallyAhead = true;
+                    scan = instr.Offset + (instr.Size || 1);
+                    break;
+                }
+                if (instr.OpCodeID !== this.OpCodes.POP_TOP) break;
+                scan = instr.Offset + (instr.Size || 1);
+            }
+
+            if (endFinallyAhead) {
+                // Distinguish try/except/else from try/except (no else) inside
+                // a loop. With else: bytecode after END_FINALLY is the else
+                // body, then a JUMP_ABSOLUTE to loop start. Without else: the
+                // very next instruction is the loop's exit JUMP_ABSOLUTE.
+                let elseEnd = scan;
+                let cursor = scan;
+                let hasBody = false;
+                for (let i = 0; i < 200; i++) {
+                    const instr = this.code.PeekInstructionAtOffset(cursor);
+                    if (!instr) break;
+                    if (instr.OpCodeID === this.OpCodes.JUMP_ABSOLUTE_A
+                            && instr.JumpTarget === this.code.Current.JumpTarget) {
+                        elseEnd = instr.Offset + (instr.Size || 3);
+                        break;
+                    }
+                    if (instr.OpCodeID === this.OpCodes.POP_BLOCK) {
+                        elseEnd = instr.Offset;
+                        break;
+                    }
+                    hasBody = true;
+                    cursor = instr.Offset + (instr.Size || 3);
+                }
+
+                if (!hasBody) {
+                    // No else body — fall through to default jump handling.
+                } else {
+                    let except = this.blocks.pop();
+                    this.curBlock = this.blocks.top();
+                    if (!except.empty()) {
+                        this.curBlock.append(except);
+                    }
+                    if (this.curBlock.blockType == AST.ASTBlock.BlockType.Container) {
+                        this.curBlock.end = elseEnd;
+                    }
+
+                    let elseblk = new AST.ASTBlock(AST.ASTBlock.BlockType.Else, this.code.Current.Offset, elseEnd);
+                    elseblk.init();
+                    this.blocks.push(elseblk);
+                    this.curBlock = this.blocks.top();
+                    return;
+                }
+            }
         } else {
             // First of all we have to figure out if there is any While or For blocks wer are in
             let loopBlock = null;
@@ -601,6 +1060,19 @@ function handleJumpAbsoluteA() {
             }
 
             if (!loopBlock) {
+                // Self-referential JUMP_ABSOLUTE with no enclosing loop is a
+                // `while True: pass` that 3.8+ emits without SETUP_LOOP. Emit a
+                // synthesized while block so the infinite loop is preserved.
+                // Pre-3.8 still has SETUP_LOOP and different jump patterns; leave
+                // those branches to the existing loop machinery.
+                if (offs === this.code.Current.Offset
+                        && this.object.Reader.versionCompare(3, 8) >= 0) {
+                    const whileBlk = new AST.ASTCondBlock(AST.ASTBlock.BlockType.While, offs, offs, null, false);
+                    whileBlk.init();
+                    whileBlk.line = this.code.Current.LineNo;
+                    whileBlk.append(new AST.ASTKeyword(AST.ASTKeyword.Word.Pass));
+                    this.curBlock.append(whileBlk);
+                }
                 return;
             }
 
@@ -825,7 +1297,27 @@ function processJumpForward() {
                 }
                 let next = null;
 
-                if (this.code.Next?.OpCodeID == this.OpCodes.END_FINALLY) {
+                // try/except/else: JUMP_FORWARD at end of except handler skips
+                // past END_FINALLY and the else body. Detect by scanning the
+                // few instructions between code.Next and the JUMP target for
+                // an END_FINALLY (Python 2.x emits POP_TOP before END_FINALLY).
+                let jumpTarget = this.code.Next?.Offset + offs;
+                let nextIsElse = this.code.Next?.OpCodeID == this.OpCodes.END_FINALLY;
+                if (!nextIsElse && this.code.PeekInstructionAtOffset) {
+                    let scan = this.code.Next?.Offset;
+                    for (let i = 0; i < 4 && scan != null && scan < jumpTarget; i++) {
+                        const instr = this.code.PeekInstructionAtOffset(scan);
+                        if (!instr) break;
+                        if (instr.OpCodeID === this.OpCodes.END_FINALLY) {
+                            nextIsElse = true;
+                            break;
+                        }
+                        if (instr.OpCodeID !== this.OpCodes.POP_TOP) break;
+                        scan = instr.Offset + instr.Size;
+                    }
+                }
+
+                if (nextIsElse) {
                     next = new AST.ASTBlock(AST.ASTBlock.BlockType.Else, this.code.Current.Offset, this.code.Current.JumpTarget);
                     next.init();
                 } else {
@@ -950,5 +1442,6 @@ module.exports = {
     handleJumpBackwardNoInterruptA,
     handleJumpIfNotExcMatchA,
     handleNotTaken,
-    handleInstrumentedNotTakenA
+    handleInstrumentedNotTakenA,
+    resolveBoolChainFrames
 };