depyo 1.0.3 → 1.2.0

package/lib/PycDecompiler.js

@@ -150,6 +150,8 @@ class PycDecompiler {
         this.enrichGenericAnnotations(functonBody);
         this.rewriteClassDefinitions(functonBody);
         this.removeNullSentinelComparisons(functonBody);
+        this.cleanupExcMatchArtifacts(functonBody);
+        this.hoistNestedExceptBlocks(functonBody);
         this.dedupeExceptHandlers(functonBody);
         this.removeDuplicateReturns(functonBody);
 
@@ -428,7 +430,19 @@ class PycDecompiler {
         if (offset === undefined) {
             return;
         }
-        const maxHandlerEnd = this.maxExceptionHandlerEnd || Math.max(...entries.filter(e => e.depth > 0).map(e => e.end || 0), 0);
+        // Exclude cleanup-only handler entries (depth>0 whose start is a RERAISE site,
+        // not a PUSH_EXC_INFO) from the try-block span. Those entries protect CPython's
+        // implicit re-raise tail, not a user-written except, and must not be treated
+        // as handler bodies when sizing the enclosing try.
+        const isUserHandlerEntry = (e) => {
+            if (!e || e.depth <= 0) return false;
+            const startInstr = this.code.PeekInstructionAtOffset(e.start);
+            return startInstr && startInstr.OpCodeID === this.OpCodes.PUSH_EXC_INFO;
+        };
+        const maxHandlerEnd = this.maxExceptionHandlerEnd || Math.max(
+            ...entries.filter(e => e.depth > 0 && isUserHandlerEntry(e)).map(e => e.end || 0),
+            0
+        );
 
         // Build set of WITH_EXCEPT_START handler ranges (lazily, once per code object)
         if (!this._withExceptRanges) {
@@ -579,6 +593,16 @@ class PycDecompiler {
                     }
                 }
             }
+            // Skip depth>0 entries whose start is a RERAISE cleanup site rather than
+            // a user-level PUSH_EXC_INFO handler. These appear in CPython 3.11+ as
+            // protected tails around `RERAISE 0` or `COPY n; POP_EXCEPT; RERAISE 1`
+            // and have no source-level except counterpart.
+            if (entry.depth > 0 && !isUserHandlerEntry(entry)) {
+                if (g_cliArgs?.debug) {
+                    console.log(`[EnsureExcBlocks] Skipping cleanup-only handler entry at ${entry.start} (not PUSH_EXC_INFO)`);
+                }
+                continue;
+            }
             const handlerEnd = entry.depth === 0
                 ? (maxHandlerEnd || entry.end || this.code.LastOffset || this.object.CodeSize || 0)
                 : (entry.end || maxHandlerEnd || this.code.LastOffset || this.object.CodeSize || 0);
@@ -644,6 +668,54 @@ class PycDecompiler {
             if (!next) break;
             end = next.end;
         }
+        // The exception-table entry only covers the prologue (the protected
+        // region around CHECK_EXC_MATCH). The actual handler body — user
+        // statements, POP_EXCEPT, and the terminating exit — lives past the
+        // entry end. Walk forward to include POP_EXCEPT and the following
+        // terminator (RETURN/JUMP_FORWARD/RERAISE) so the Except block
+        // captures the body that renders as user code.
+        if (this.code && this.OpCodes) {
+            let cursor = end;
+            let steps = 0;
+            let sawHandlerExit = false;
+            while (cursor >= 0 && steps++ < 500) {
+                const instr = this.code.PeekInstructionAtOffset(cursor);
+                if (!instr) break;
+                const op = instr.OpCodeID;
+                // Stop if we enter another handler's prologue.
+                if (op === this.OpCodes.PUSH_EXC_INFO) break;
+                if (op === this.OpCodes.POP_EXCEPT) {
+                    sawHandlerExit = true;
+                    end = instr.Offset + (instr.Size || 2);
+                    cursor = end;
+                    continue;
+                }
+                if (sawHandlerExit && (
+                    op === this.OpCodes.RETURN_VALUE ||
+                    op === this.OpCodes.RETURN_VALUE_A ||
+                    op === this.OpCodes.RETURN_CONST_A ||
+                    op === this.OpCodes.JUMP_FORWARD ||
+                    op === this.OpCodes.JUMP_FORWARD_A ||
+                    op === this.OpCodes.JUMP_BACKWARD ||
+                    op === this.OpCodes.JUMP_BACKWARD_A ||
+                    op === this.OpCodes.RERAISE ||
+                    op === this.OpCodes.RERAISE_A)) {
+                    end = instr.Offset + (instr.Size || 2);
+                    break;
+                }
+                if (sawHandlerExit) {
+                    // Skip trailing CACHE/POP_TOP cleanup that sometimes sits
+                    // between POP_EXCEPT and the terminator on 3.11+.
+                    if (op === this.OpCodes.CACHE ||
+                        op === this.OpCodes.POP_TOP) {
+                        cursor = instr.Offset + (instr.Size || 2);
+                        continue;
+                    }
+                    break;
+                }
+                cursor = instr.Offset + (instr.Size || 2);
+            }
+        }
         return end;
     }
     
@@ -861,6 +933,23 @@ class PycDecompiler {
                         break;  // This WITH block hasn't reached its end yet
                     }
 
+                    // Close any blocks ABOVE this WITH whose end is also reached.
+                    // 3.14 with-bodies that contain an if/else commonly have the
+                    // else's end coincide with the with's end (both target the
+                    // post-with cleanup offset). If we close the WITH while an
+                    // Else is still open above it, the else body gets reparented
+                    // to the WITH's parent — producing a stray `else:` dedented
+                    // out of the with-block in the rendered source.
+                    while (this.blocks.length - 1 > withIdx) {
+                        const above = this.blocks.top();
+                        if (above.end <= 0 || this.code.Current.Offset < above.end) {
+                            break;
+                        }
+                        this.blocks.pop();
+                        const newTop = this.blocks.top();
+                        if (newTop) newTop.append(above);
+                    }
+
                     // Close this WITH block
                     this.blocks.splice(withIdx, 1);
                     const parentBlock = this.blocks[withIdx - 1] || this.blocks.top();
@@ -1653,11 +1742,45 @@ class PycDecompiler {
             if (hasDataclass) {
                 node.addDecorator(new AST.ASTName('dataclass'));
             }
+        } else if (node.src instanceof AST.ASTCall && this.isDecoratedClassCall(node.src)) {
+            // Pattern: `Name = decorator(ClassLiteral[, ...])` produced by Py3.12+
+            // dataclass/decorator-of-class flows. Promote to a real class with
+            // the call-of-decorator attached as an @decorator.
+            const call = node.src;
+            const classNode = call.pparams[0];
+            const decoratorExpr = this._buildDecoratorExpr(call);
+            node.src = classNode;
+            this.cleanupClassBody(classNode);
+            if (decoratorExpr) {
+                node.addDecorator(decoratorExpr);
+            }
         } else if (node.src instanceof AST.ASTClass) {
             this.cleanupClassBody(node.src);
         }
     }
 
+    isDecoratedClassCall(call) {
+        if (!(call instanceof AST.ASTCall)) return false;
+        if (call.func instanceof AST.ASTClass) return false;
+        if (!call.pparams || call.pparams.length < 1) return false;
+        if (!(call.pparams[0] instanceof AST.ASTClass)) return false;
+        // Any further pparams would become positional args to the decorator,
+        // which cannot be expressed as `@decorator(class)` sugar. Reject.
+        return call.pparams.length === 1;
+    }
+
+    _buildDecoratorExpr(call) {
+        // `decorator(class)` → `@decorator`
+        // `decorator(class, kw=val, ...)` → `@decorator(kw=val, ...)`
+        const kwargs = call.kwparams || [];
+        if (kwargs.length === 0 && !call.hasVar && !call.hasKw) {
+            return call.func;
+        }
+        const wrapper = new AST.ASTCall(call.func, [], kwargs);
+        wrapper.line = call.line;
+        return wrapper;
+    }
+
     _childContainers(node) {
         const containers = [];
         if (node instanceof AST.ASTBlock) {
@@ -1801,6 +1924,635 @@ class PycDecompiler {
         }
     }
 
+    // Rewrites 3.11+ CHECK_EXC_MATCH artifacts that leaked past block
+    // reconstruction: unwraps `except <exc> EXC_MATCH <type>` conditions
+    // down to `<type>`, rewrites sibling `while __exception__ EXC_MATCH T:`
+    // blocks into `except T:` handlers on the preceding Try, and strips
+    // trailing compiler-generated reraise/cleanup nodes (bare `raise`,
+    // `e = None; del e`, empty `try: pass`). Runs once on the whole tree.
+    cleanupExcMatchArtifacts(root) {
+        // Pre-3.11 except-as handlers still need two cleanups: strip the
+        // `X = None; del X` pair CPython emits after every `except ... as X:`
+        // body (PEP 3134), and unwrap the synthetic `try: body / finally: pass`
+        // that wraps the handler body (CPython lowers `except ... as X:` to
+        // `try: body; finally: X = None; del X`, and the finally body ends up
+        // emptied as the X=None/del X move out to the handler tail).
+        if (this.object.Reader.versionCompare(3, 11) < 0) {
+            this.cleanupPre311ExceptAsArtifacts(root);
+            return;
+        }
+
+        const EXC_MATCH = AST.ASTCompare.CompareOp.Exception;
+
+        const unwrapExcMatch = (cond) => {
+            if (!cond) return cond;
+            // The condition may have been wrapped in ASTStore (alias binding) -
+            // unwrap first, then strip the EXC_MATCH compare.
+            let inner = cond;
+            if (inner instanceof AST.ASTStore && inner.src) {
+                inner = inner.src;
+            }
+            if (inner instanceof AST.ASTCompare && inner.op === EXC_MATCH) {
+                return inner.right;
+            }
+            return cond;
+        };
+
+        const isExcMatchCompare = (node) =>
+            node instanceof AST.ASTCompare && node.op === EXC_MATCH;
+
+        const isExceptionName = (node) =>
+            node instanceof AST.ASTName && node.name === '__exception__';
+
+        const containsExceptionRef = (node, depth = 0) => {
+            if (!node || depth > 4) return false;
+            if (isExceptionName(node)) return true;
+            if (node instanceof AST.ASTCompare || node instanceof AST.ASTBinary) {
+                return containsExceptionRef(node.left, depth + 1) ||
+                       containsExceptionRef(node.right, depth + 1);
+            }
+            if (node instanceof AST.ASTCall) {
+                return containsExceptionRef(node.func, depth + 1) ||
+                       (node.pparams || []).some(p => containsExceptionRef(p, depth + 1));
+            }
+            if (node instanceof AST.ASTStore) {
+                return containsExceptionRef(node.src, depth + 1);
+            }
+            return false;
+        };
+
+        const isEmptyTryBlock = (node) =>
+            node instanceof AST.ASTBlock &&
+            node.blockType === AST.ASTBlock.BlockType.Try &&
+            (node.nodes.length === 0 ||
+             (node.nodes.length === 1 &&
+              node.nodes[0] instanceof AST.ASTKeyword &&
+              node.nodes[0].key === AST.ASTKeyword.Word.Pass));
+
+        const isOrphanExceptionStmt = (node) => {
+            // Bare `raise` with no params → fall-through RERAISE artifact
+            if (node instanceof AST.ASTRaise && (!node.params || node.params.length === 0)) {
+                return true;
+            }
+            // `__exception__(None, None, None)` or `__exception__` alone
+            if (node instanceof AST.ASTCall && isExceptionName(node.func)) {
+                return true;
+            }
+            if (isExceptionName(node)) {
+                return true;
+            }
+            // `x = __exception__` - CPython alias-clear artifact
+            if (node instanceof AST.ASTStore && isExceptionName(node.src)) {
+                return true;
+            }
+            // `return __exception__` - misrendered reraise epilogue
+            if (node instanceof AST.ASTReturn && isExceptionName(node.value)) {
+                return true;
+            }
+            return false;
+        };
+
+        const rewriteContainer = (nodes, parentBlockType) => {
+            if (!Array.isArray(nodes)) return;
+
+            // Pass 1: unwrap EXC_MATCH in Except block conditions.
+            for (const node of nodes) {
+                if (node instanceof AST.ASTCondBlock &&
+                    node.blockType === AST.ASTBlock.BlockType.Except) {
+                    node.condition = unwrapExcMatch(node.condition);
+                }
+            }
+
+            // Pass 2: convert ASTWhile/ASTIf with EXC_MATCH condition to Except
+            // handlers and attach them to the preceding Try block. If no preceding
+            // Try exists (deeply misparsed region), drop them to avoid invalid output.
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                const node = nodes[i];
+                if (!(node instanceof AST.ASTCondBlock) ||
+                    !(node.blockType === AST.ASTBlock.BlockType.While ||
+                      node.blockType === AST.ASTBlock.BlockType.If)) {
+                    continue;
+                }
+                if (!isExcMatchCompare(node.condition) ||
+                    !containsExceptionRef(node.condition.left)) {
+                    continue;
+                }
+                const matchType = node.condition.right;
+                // Find nearest preceding Try block in this container.
+                let tryIdx = -1;
+                for (let j = i - 1; j >= 0; j--) {
+                    const cand = nodes[j];
+                    if (cand instanceof AST.ASTBlock &&
+                        cand.blockType === AST.ASTBlock.BlockType.Try) {
+                        tryIdx = j;
+                        break;
+                    }
+                    // Allow existing Except handlers between; skip past them.
+                    if (cand instanceof AST.ASTCondBlock &&
+                        cand.blockType === AST.ASTBlock.BlockType.Except) {
+                        continue;
+                    }
+                    break;
+                }
+                // Strip any trailing orphan reraise/alias-clear statements from body.
+                const cleanBody = node.nodes.filter(n => !isOrphanExceptionStmt(n));
+                if (cleanBody.length === 0) {
+                    cleanBody.push(new AST.ASTKeyword(AST.ASTKeyword.Word.Pass));
+                }
+
+                if (tryIdx >= 0) {
+                    const exceptBlk = new AST.ASTCondBlock(
+                        AST.ASTBlock.BlockType.Except,
+                        node.start, node.end, matchType, false);
+                    exceptBlk.line = node.line;
+                    exceptBlk.m_nodes = cleanBody;
+                    // Insert right after last existing Except handler for that Try.
+                    let insertAt = tryIdx + 1;
+                    while (insertAt < nodes.length &&
+                           nodes[insertAt] instanceof AST.ASTCondBlock &&
+                           nodes[insertAt].blockType === AST.ASTBlock.BlockType.Except) {
+                        insertAt++;
+                    }
+                    nodes.splice(i, 1);
+                    if (insertAt > i) insertAt--;
+                    nodes.splice(insertAt, 0, exceptBlk);
+                } else {
+                    // No Try to attach to — dropping keeps output parseable.
+                    nodes.splice(i, 1);
+                }
+            }
+
+            // Pass 3: strip orphan exception-related statements at container
+            // level — but NOT inside Except/Finally bodies, where bare `raise`
+            // is a legitimate re-raise statement.
+            const inHandlerBody = parentBlockType === AST.ASTBlock.BlockType.Except ||
+                                  parentBlockType === AST.ASTBlock.BlockType.Finally;
+            if (!inHandlerBody) {
+                for (let i = nodes.length - 1; i >= 0; i--) {
+                    if (isOrphanExceptionStmt(nodes[i])) {
+                        nodes.splice(i, 1);
+                    }
+                }
+            }
+
+            // Pass 3.5: strip `X = None; del X` pairs — CPython 3.11+ emits this
+            // at the tail/fall-through of every `except Foo as X:` body to clear
+            // the binding. The pattern is synthetic and user code effectively
+            // never writes it literally, so removing it is safe and prevents
+            // the artifact from breaking up adjacent except clauses.
+            for (let i = nodes.length - 2; i >= 0; i--) {
+                const a = nodes[i], b = nodes[i + 1];
+                if (a instanceof AST.ASTStore &&
+                    a.src instanceof AST.ASTNone &&
+                    a.dest instanceof AST.ASTName &&
+                    b instanceof AST.ASTDelete &&
+                    b.value instanceof AST.ASTName &&
+                    a.dest.name === b.value.name) {
+                    nodes.splice(i, 2);
+                }
+            }
+
+            // Pass 4: drop empty `try:` blocks. With no following handler the
+            // try is a bare leftover. With a trivial `except: pass` handler the
+            // whole pair is a reconstruction artifact — Python forbids
+            // `try:<empty>`, so either outcome requires the try to go. When the
+            // handler has real body drop only the try and splice a `pass`
+            // placeholder into the handler's matching — but the current
+            // sightings all have pass-only handlers, so mirror that case.
+            const isTrivialHandlerBlock = (n) =>
+                n instanceof AST.ASTCondBlock &&
+                (n.blockType === AST.ASTBlock.BlockType.Except ||
+                 n.blockType === AST.ASTBlock.BlockType.Finally) &&
+                (n.nodes.length === 0 ||
+                 (n.nodes.length === 1 &&
+                  n.nodes[0] instanceof AST.ASTKeyword &&
+                  n.nodes[0].key === AST.ASTKeyword.Word.Pass));
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                if (!isEmptyTryBlock(nodes[i])) continue;
+                const next = nodes[i + 1];
+                const hasHandler = next instanceof AST.ASTCondBlock &&
+                    (next.blockType === AST.ASTBlock.BlockType.Except ||
+                     next.blockType === AST.ASTBlock.BlockType.Finally);
+                if (!hasHandler) {
+                    nodes.splice(i, 1);
+                    continue;
+                }
+                // Walk all trailing handlers; drop the whole cluster iff every
+                // one is a trivial pass-body — keeping any would still leave
+                // the empty try as a syntax error anyway.
+                let tailEnd = i + 1;
+                while (tailEnd < nodes.length && isTrivialHandlerBlock(nodes[tailEnd])) {
+                    tailEnd++;
+                }
+                const allTrivial = tailEnd > i + 1 &&
+                    nodes.slice(i + 1, tailEnd).every(isTrivialHandlerBlock) &&
+                    (tailEnd === nodes.length ||
+                     !(nodes[tailEnd] instanceof AST.ASTCondBlock &&
+                       (nodes[tailEnd].blockType === AST.ASTBlock.BlockType.Except ||
+                        nodes[tailEnd].blockType === AST.ASTBlock.BlockType.Finally)));
+                if (allTrivial) {
+                    nodes.splice(i, tailEnd - i);
+                }
+            }
+
+            // Pass 4.5: move a sibling Except/Finally that immediately follows
+            // a Try into the Try's body. When CFG reconstruction hoists the
+            // handler one level up (e.g. into the parent Else), the block
+            // renderer dedents `except:` to the parent's indent — producing
+            // `else: / try: / except:` where `except:` lands at the `else:`
+            // column instead of the `try:` column, which is a SyntaxError.
+            // Absorbing the handler into the Try body lets the renderer's
+            // single-step dedent land it at the correct `try:` column.
+            for (let i = 0; i < nodes.length - 1; i++) {
+                const cur = nodes[i];
+                if (!(cur instanceof AST.ASTBlock) ||
+                    cur.blockType !== AST.ASTBlock.BlockType.Try) continue;
+                const next = nodes[i + 1];
+                if (!(next instanceof AST.ASTCondBlock)) continue;
+                if (next.blockType !== AST.ASTBlock.BlockType.Except &&
+                    next.blockType !== AST.ASTBlock.BlockType.Finally) continue;
+                // Skip if the Try already carries its own trailing handler —
+                // moving another one in would stack two handlers, which is
+                // only valid for multi-except chains (same Try). Those cases
+                // already render fine.
+                const last = cur.nodes[cur.nodes.length - 1];
+                const hasOwnHandler = last instanceof AST.ASTCondBlock &&
+                    (last.blockType === AST.ASTBlock.BlockType.Except ||
+                     last.blockType === AST.ASTBlock.BlockType.Finally);
+                if (hasOwnHandler) continue;
+                // Empty Try bodies + non-trivial handler would collapse to an
+                // invalid `try: / except:` with nothing between. Inject a
+                // `pass` so the rendered block is syntactically valid.
+                if (cur.nodes.length === 0) {
+                    cur.nodes.push(new AST.ASTKeyword(AST.ASTKeyword.Word.Pass));
+                }
+                cur.nodes.push(next);
+                nodes.splice(i + 1, 1);
+            }
+
+            // Pass 5: a Try block with a non-empty body but no following
+            // Except/Finally handler is a SyntaxError. Append a synthetic
+            // `except: pass` so the output parses — real structural recovery
+            // needs dedicated work, but the fallback keeps the file usable.
+            // Skip when the Try already has an Except/Finally nested in its
+            // body (except* groups build nested handler structures).
+            for (let i = 0; i < nodes.length; i++) {
+                const cur = nodes[i];
+                if (!(cur instanceof AST.ASTBlock) ||
+                    cur.blockType !== AST.ASTBlock.BlockType.Try) {
+                    continue;
+                }
+                if (cur.nodes.length === 0) continue;
+                const next = nodes[i + 1];
+                const hasHandler = next instanceof AST.ASTCondBlock &&
+                    (next.blockType === AST.ASTBlock.BlockType.Except ||
+                     next.blockType === AST.ASTBlock.BlockType.Finally);
+                if (hasHandler) continue;
+                const hasNestedExcept = cur.nodes.some(n =>
+                    n instanceof AST.ASTCondBlock &&
+                    (n.blockType === AST.ASTBlock.BlockType.Except ||
+                     n.blockType === AST.ASTBlock.BlockType.Finally));
+                if (hasNestedExcept) continue;
+                const synthetic = new AST.ASTCondBlock(
+                    AST.ASTBlock.BlockType.Except,
+                    cur.end, cur.end, null, false);
+                synthetic.line = cur.line;
+                synthetic.m_nodes.push(new AST.ASTKeyword(AST.ASTKeyword.Word.Pass));
+                nodes.splice(i + 1, 0, synthetic);
+                i++;
+            }
+
+            // Pass 5.5: adopt orphan Except into a preceding branch whose
+            // body ends with an un-paired Try. CPython can emit a try/except
+            // inside the tail of an if/else branch so that, after CFG
+            // reconstruction, the Try ends up as the last child of the branch
+            // while its handler gets hoisted one level up as a stray sibling.
+            // Moving the handler back in keeps the pair valid. Absorbed
+            // trailing statements stay in the handler body — not semantically
+            // correct, but renders to parseable Python instead of a stray
+            // `except:` at the outer indent.
+            const branchTypes = [
+                AST.ASTBlock.BlockType.If,
+                AST.ASTBlock.BlockType.Elif,
+                AST.ASTBlock.BlockType.Else,
+            ];
+            const endsWithOrphanTry = (block) => {
+                if (!(block instanceof AST.ASTBlock)) return false;
+                if (!branchTypes.includes(block.blockType)) return false;
+                const body = block.nodes;
+                if (!body || body.length === 0) return false;
+                const last = body[body.length - 1];
+                if (!(last instanceof AST.ASTBlock) ||
+                    last.blockType !== AST.ASTBlock.BlockType.Try) {
+                    return false;
+                }
+                const hasHandlerInside = last.nodes.some(n =>
+                    n instanceof AST.ASTCondBlock &&
+                    (n.blockType === AST.ASTBlock.BlockType.Except ||
+                     n.blockType === AST.ASTBlock.BlockType.Finally));
+                return !hasHandlerInside;
+            };
+            for (let i = nodes.length - 1; i > 0; i--) {
+                const cur = nodes[i];
+                if (!(cur instanceof AST.ASTCondBlock)) continue;
+                if (cur.blockType !== AST.ASTBlock.BlockType.Except &&
+                    cur.blockType !== AST.ASTBlock.BlockType.Finally) continue;
+                const prev = nodes[i - 1];
+                if (!endsWithOrphanTry(prev)) continue;
+                // Confirm there's no matching Try at this container level,
+                // otherwise leave the pair alone.
+                let hasLocalTry = false;
+                for (let j = i - 1; j >= 0; j--) {
+                    const p = nodes[j];
+                    if (p instanceof AST.ASTBlock &&
+                        p.blockType === AST.ASTBlock.BlockType.Try) {
+                        hasLocalTry = true;
+                        break;
+                    }
+                    if (p instanceof AST.ASTCondBlock &&
+                        (p.blockType === AST.ASTBlock.BlockType.Except ||
+                         p.blockType === AST.ASTBlock.BlockType.Finally)) {
+                        continue;
+                    }
+                    break;
+                }
+                if (hasLocalTry) continue;
+                prev.nodes.push(cur);
+                nodes.splice(i, 1);
+            }
+
+            // Pass 6: drop orphan Except/Finally blocks that have no matching
+            // Try (or preceding Except) anywhere earlier in this container.
+            // These are leftovers from misreconstructed CFGs — keeping them
+            // produces SyntaxError at parse time. Inside a Try body Except
+            // can legitimately nest (Py3.11+ handler layout, except* groups),
+            // but only at the tail. A mid-body Except with non-handler
+            // statements after it is a stray handler — drop it.
+            const inTryBody = parentBlockType === AST.ASTBlock.BlockType.Try;
+            const isHandlerBlock = (x) =>
+                x instanceof AST.ASTCondBlock &&
+                (x.blockType === AST.ASTBlock.BlockType.Except ||
+                 x.blockType === AST.ASTBlock.BlockType.Finally);
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                const cur = nodes[i];
+                if (!(cur instanceof AST.ASTCondBlock)) continue;
+                if (cur.blockType !== AST.ASTBlock.BlockType.Except &&
+                    cur.blockType !== AST.ASTBlock.BlockType.Finally) continue;
+                if (inTryBody) {
+                    // except* groups have complex internal structure — never
+                    // touch them.
+                    if (cur.isExceptStar) continue;
+                    // For regular Except nested inside Try body (Py3.11+
+                    // handler layout): legitimate only when at the tail.
+                    let allTrailingHandlers = true;
+                    for (let k = i + 1; k < nodes.length; k++) {
+                        if (!isHandlerBlock(nodes[k])) {
+                            allTrailingHandlers = false;
+                            break;
+                        }
+                    }
+                    if (allTrailingHandlers) continue;
+                }
+                let anchorFound = false;
+                for (let j = i - 1; j >= 0; j--) {
+                    const prev = nodes[j];
+                    if (prev instanceof AST.ASTBlock &&
+                        prev.blockType === AST.ASTBlock.BlockType.Try) {
+                        anchorFound = true;
+                        break;
+                    }
+                    if (prev instanceof AST.ASTCondBlock &&
+                        (prev.blockType === AST.ASTBlock.BlockType.Except ||
+                         prev.blockType === AST.ASTBlock.BlockType.Finally)) {
+                        continue;
+                    }
+                    break;
+                }
+                if (!anchorFound) nodes.splice(i, 1);
+            }
+
+            // Pass 7: after earlier passes may have emptied a Try body, drop
+            // Try+trivial-Except pairs where the body is now empty. Python
+            // forbids `try:` with no body; a pass-only handler carries no
+            // recoverable intent, so splice the cluster out entirely.
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                if (!isEmptyTryBlock(nodes[i])) continue;
+                let tailEnd = i + 1;
+                while (tailEnd < nodes.length && isTrivialHandlerBlock(nodes[tailEnd])) {
+                    tailEnd++;
+                }
+                if (tailEnd === i + 1) continue;
+                const trailingHandler = nodes[tailEnd] instanceof AST.ASTCondBlock &&
+                    (nodes[tailEnd].blockType === AST.ASTBlock.BlockType.Except ||
+                     nodes[tailEnd].blockType === AST.ASTBlock.BlockType.Finally);
+                if (trailingHandler) continue;
+                nodes.splice(i, tailEnd - i);
+            }
+        };
+
+        // Post-order traversal: process children before parent so nested
+        // emptyings bubble up — an outer Try can only be recognised as empty
+        // after the inner Try/Except artifacts inside its body were dropped.
+        const visited = new WeakSet();
+        const visit = (n) => {
+            if (!n || visited.has(n)) return;
+            visited.add(n);
+            let nodes = null;
+            let parentType = null;
+            if (n instanceof AST.ASTNodeList) {
+                nodes = n.list;
+                parentType = null;
+            } else if (n instanceof AST.ASTBlock) {
+                nodes = n.nodes;
+                parentType = n.blockType;
+            } else if (n instanceof AST.ASTStore && n.src instanceof AST.ASTFunction) {
+                const body = n.src.code?.object?.SourceCode;
+                if (body) visit(body);
+                return;
+            }
+            if (nodes) {
+                for (const c of nodes) visit(c);
+                rewriteContainer(nodes, parentType);
+            }
+        };
+        visit(root);
+    }
+
+    // Pre-3.11 `except Foo as X:` expands to `try: body / finally: X = None;
+    // del X`. The decompiler hoists the cleanup out to the handler tail,
+    // leaving `try: body / finally: pass / X = None / del X`. Strip the pair
+    // and unwrap the synthetic try/finally so the handler renders as `body`.
+    cleanupPre311ExceptAsArtifacts(root) {
+        const isNoneDelPair = (a, b) =>
+            a instanceof AST.ASTStore &&
+            a.src instanceof AST.ASTNone &&
+            a.dest instanceof AST.ASTName &&
+            b instanceof AST.ASTDelete &&
+            b.value instanceof AST.ASTName &&
+            a.dest.name === b.value.name;
+
+        const isFinallyTrivial = (n) =>
+            n instanceof AST.ASTBlock &&
+            n.blockType === AST.ASTBlock.BlockType.Finally &&
+            (n.nodes.length === 0 ||
+             (n.nodes.length === 1 &&
+              n.nodes[0] instanceof AST.ASTKeyword &&
+              n.nodes[0].key === AST.ASTKeyword.Word.Pass));
+
+        // A CPython `except Foo as X:` body wraps user code in a synthetic
+        // `try: body / finally: X=None; del X`. After the Pass 3.5 strip the
+        // finally becomes empty / pass-only, leaving an ASTContainerBlock
+        // whose children are [Try(body), Finally(pass)]. Collapse that back
+        // to just the try-body so the handler renders as `body`.
+        const unwrapTryFinallyPassContainer = (nodes) => {
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                const cont = nodes[i];
+                if (!(cont instanceof AST.ASTContainerBlock)) continue;
+                const children = cont.nodes;
+                if (!children || children.length !== 2) continue;
+                const tryBlk = children[0];
+                const finBlk = children[1];
+                if (!(tryBlk instanceof AST.ASTBlock) ||
+                    tryBlk.blockType !== AST.ASTBlock.BlockType.Try) continue;
+                if (!isFinallyTrivial(finBlk)) continue;
+                if (tryBlk.nodes.length === 0) continue;
+                // Keep real user try/except nested inside — unwrapping
+                // would change semantics when the try body itself carries
+                // handlers that could fire.
+                const hasNestedHandler = tryBlk.nodes.some(n =>
+                    n instanceof AST.ASTCondBlock &&
+                    (n.blockType === AST.ASTBlock.BlockType.Except ||
+                     n.blockType === AST.ASTBlock.BlockType.Finally));
+                if (hasNestedHandler) continue;
+                nodes.splice(i, 1, ...tryBlk.nodes);
+            }
+        };
+
+        const stripNoneDelPairs = (nodes) => {
+            for (let i = nodes.length - 2; i >= 0; i--) {
+                if (isNoneDelPair(nodes[i], nodes[i + 1])) {
+                    nodes.splice(i, 2);
+                }
+            }
+        };
+
+        const visited = new WeakSet();
+        const visit = (n) => {
+            if (!n || visited.has(n)) return;
+            visited.add(n);
+            let nodes = null;
+            let parentType = null;
+            if (n instanceof AST.ASTNodeList) {
+                nodes = n.list;
+            } else if (n instanceof AST.ASTBlock) {
+                nodes = n.nodes;
+                parentType = n.blockType;
+            } else if (n instanceof AST.ASTStore && n.src instanceof AST.ASTFunction) {
+                const body = n.src.code?.object?.SourceCode;
+                if (body) visit(body);
+                return;
+            }
+            if (nodes) {
+                for (const c of nodes) visit(c);
+                stripNoneDelPairs(nodes);
+                // The try/finally:pass wrapper is CPython's synthetic scaffold
+                // for `except Foo as X:` — only unwrap inside Except bodies,
+                // otherwise real user-written `try: body / finally: pass`
+                // constructs at top-level/function body get collapsed too.
+                if (parentType === AST.ASTBlock.BlockType.Except) {
+                    unwrapTryFinallyPassContainer(nodes);
+                }
+            }
+        };
+        visit(root);
+    }
+
+    // An Except block can get reconstructed inside a non-Try block's body
+    // (most often a For/While/If inside the protected try-body) when the
+    // handler's offset range overlaps a nested loop. Python requires the
+    // except clause to sit next to its `try:`, so walk the tree and pull
+    // such Except blocks out of any non-Try ancestor until they become a
+    // sibling of their enclosing Try.
+    hoistNestedExceptBlocks(root) {
+        const isHoistableBlock = (node) =>
+            node instanceof AST.ASTBlock &&
+            node.blockType !== AST.ASTBlock.BlockType.Try;
+
+        const isExcept = (node) =>
+            node instanceof AST.ASTCondBlock &&
+            node.blockType === AST.ASTBlock.BlockType.Except;
+
+        // Fixed-point loop: one pass hoists Except up one level. Bounded by
+        // tree depth; excessive iterations just exit.
+        for (let iter = 0; iter < 64; iter++) {
+            let moved = false;
+            const stack = [{container: null, nodes: null, parent: null}];
+            const parentMap = new WeakMap(); // child container → {arr, index, parent}
+
+            const visit = (arr, parentInfo) => {
+                for (let i = 0; i < arr.length; i++) {
+                    const n = arr[i];
+                    if (!n) continue;
+                    let children = null;
+                    if (n instanceof AST.ASTBlock || n instanceof AST.ASTCondBlock) {
+                        children = n.nodes;
+                    } else if (n instanceof AST.ASTNodeList) {
+                        children = n.list;
+                    } else if (n instanceof AST.ASTStore && n.src instanceof AST.ASTFunction) {
+                        const src = n.src.code?.object?.SourceCode;
+                        if (src instanceof AST.ASTNodeList) {
+                            visit(src.list, null);
+                        }
+                        continue;
+                    }
+                    if (Array.isArray(children) && children.length > 0) {
+                        // If this block is non-Try and its first child is an
+                        // Except, pull that Except out into the parent arr
+                        // right after `n`.
+                        if (isHoistableBlock(n)) {
+                            // Scan forward for leading Except children only;
+                            // an Except appearing later in the body is usually
+                            // a real construct we should leave alone.
+                            while (children.length > 0 && isExcept(children[0])) {
+                                const ex = children.shift();
+                                arr.splice(i + 1, 0, ex);
+                                moved = true;
+                            }
+                        }
+                        visit(children, {arr, index: i});
+                    }
+                }
+            };
+
+            const roots = [];
+            if (root instanceof AST.ASTNodeList) roots.push(root.list);
+            else if (root instanceof AST.ASTBlock) roots.push(root.nodes);
+
+            for (const r of roots) visit(r, null);
+
+            // Also dive into nested function bodies.
+            const walk = (n, seen) => {
+                if (!n || seen.has(n)) return;
+                seen.add(n);
+                if (n instanceof AST.ASTStore && n.src instanceof AST.ASTFunction) {
+                    const src = n.src.code?.object?.SourceCode;
+                    if (src instanceof AST.ASTNodeList) {
+                        visit(src.list, null);
+                    }
+                }
+                let children = null;
+                if (n instanceof AST.ASTNodeList) children = n.list;
+                else if (n instanceof AST.ASTBlock || n instanceof AST.ASTCondBlock) children = n.nodes;
+                if (Array.isArray(children)) {
+                    for (const c of children) walk(c, seen);
+                }
+            };
+            walk(root, new WeakSet());
+
+            if (!moved) break;
+        }
+    }
+
     dedupeExceptHandlers(root) {
         const queue = [root];
         const visited = new WeakSet();
@@ -2085,6 +2837,14 @@ class PycDecompiler {
                     const frag = ch?.codeFragment?.()?.toString?.() || "";
                     return frag === "pass" || frag.includes("__exception__") || frag.includes("##ERROR##");
                 }))) {
+                // Drop only synthetic except* handlers without a user condition.
+                // User-written `except:` / `except E:` must be preserved; replace
+                // cleanup-only body with `pass` so the try statement stays valid.
+                if (node.isExceptStar && !node.condition) {
+                    continue;
+                }
+                node.m_nodes = [new AST.ASTKeyword(AST.ASTKeyword.Word.Pass)];
+                rewritten.push(node);
                 continue;
             }
             if (typeof node?.codeFragment === 'function') {