depyo 1.2.0 → 1.2.2

package/lib/PycDecompiler.js

@@ -2436,6 +2436,46 @@ class PycDecompiler {
             }
         };
 
+        // CPython 3.6+ `except Foo as X:` lowers to a try/finally cleanup
+        // wrapper around the handler body. The reconstruction sometimes
+        // emits the handler ASTCondBlock twice when the inner cleanup's
+        // END_FINALLY is misread as a second handler match. Collapse
+        // consecutive identical Except blocks (same rendered condition +
+        // body) since real Python source can't legally have them.
+        const dedupeConsecutiveExcepts = (nodes) => {
+            const renderedKey = (n) => {
+                try {
+                    const cf = n.codeFragment?.();
+                    return typeof cf === 'string' ? cf : (cf?.toString?.() || null);
+                } catch (e) {
+                    return null;
+                }
+            };
+            const isExcept = (n) => (n instanceof AST.ASTCondBlock)
+                && n.blockType === AST.ASTBlock.BlockType.Except;
+            // Walk runs of contiguous Except siblings and drop duplicates
+            // (handles both adjacent and non-adjacent duplicates within
+            // the same handler chain — e.g. `except A / except: / except A`).
+            let i = 0;
+            while (i < nodes.length) {
+                if (!isExcept(nodes[i])) { i++; continue; }
+                let j = i;
+                while (j < nodes.length && isExcept(nodes[j])) j++;
+                const seen = new Map();
+                for (let k = i; k < j; k++) {
+                    const key = renderedKey(nodes[k]);
+                    if (key && seen.has(key)) {
+                        nodes.splice(k, 1);
+                        j--;
+                        k--;
+                    } else if (key) {
+                        seen.set(key, true);
+                    }
+                }
+                i = j;
+            }
+        };
+
         const visited = new WeakSet();
         const visit = (n) => {
             if (!n || visited.has(n)) return;
@@ -2462,6 +2502,10 @@ class PycDecompiler {
                 if (parentType === AST.ASTBlock.BlockType.Except) {
                     unwrapTryFinallyPassContainer(nodes);
                 }
+                // Dedupe at every level (Container, Try, NodeList) since the
+                // duplicate Except siblings can land in any of these depending
+                // on how SETUP_FINALLY/END_FINALLY interleave.
+                dedupeConsecutiveExcepts(nodes);
             }
         };
         visit(root);

package/lib/handlers/collections_update.js

@@ -95,6 +95,14 @@ function processListAppend() {
         let node = new AST.ASTComprehension (value);
         node.line = this.code.Current.LineNo;
         this.dataStack.push(node);
+    } else if (list instanceof AST.ASTList) {
+        // CPython's "big list" path: when a list literal exceeds the
+        // STACK_USE_GUIDELINE and not every element is a compile-time
+        // constant, the compiler emits BUILD_LIST 0 + N×LIST_APPEND
+        // instead of a single BUILD_LIST N. Mutate the list literal in
+        // place; the list reference must remain on top of the data stack
+        // for the next LIST_APPEND (or the final STORE_*) to find it.
+        list.values.push(value);
     } else {
         let node = new AST.ASTSubscr (list, value);
         node.line = this.code.Current.LineNo;

package/lib/handlers/control_flow_jumps.js

@@ -1177,12 +1177,37 @@ function handleJumpAbsoluteA() {
                 this.blocks.push(next);
                 prev = null;
             } else if (prev.blockType == AST.ASTBlock.BlockType.Except) {
-                let top = this.blocks.top();
-                let next = new AST.ASTCondBlock(AST.ASTBlock.BlockType.Except, top.start, top.end, null, false);
-                next.init();
+                // After closing one handler we speculatively open a fresh
+                // Except slot in case another handler follows. But if the
+                // chain has no more user-written handlers — only CPython's
+                // synthetic END_FINALLY re-raise terminator before our
+                // jump target — pushing an empty Except here produces a
+                // phantom `except: pass` in the output.
+                let chainTerminated = false;
+                const target = this.code.Current.JumpTarget;
+                const cursorStart = this.code.Next?.Offset;
+                if (target != null && cursorStart != null && cursorStart < target) {
+                    let cursor = cursorStart;
+                    for (let k = 0; k < 32 && cursor < target; k++) {
+                        const instr = this.code.PeekInstructionAtOffset(cursor);
+                        if (!instr) break;
+                        if (instr.OpCodeID === this.OpCodes.END_FINALLY) {
+                            chainTerminated = true;
+                            break;
+                        }
+                        cursor = instr.Offset + (instr.Size || 1);
+                    }
+                }
+                if (chainTerminated) {
+                    prev = null;
+                } else {
+                    let top = this.blocks.top();
+                    let next = new AST.ASTCondBlock(AST.ASTBlock.BlockType.Except, top.start, top.end, null, false);
+                    next.init();
 
-                this.blocks.push(next);
-                prev = null;
+                    this.blocks.push(next);
+                    prev = null;
+                }
             } else if (prev.blockType == AST.ASTBlock.BlockType.Else) {
                 /* Special case */
                 if (this.blocks.top().blockType != AST.ASTBlock.BlockType.Main) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "depyo",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Python bytecode decompiler (Python 1.0–3.15) implemented in Node.js",
   "bin": {
     "depyo": "./depyo.js"