depyo 1.0.3 → 1.2.0

package/lib/handlers/misc_other.js

@@ -241,11 +241,25 @@ function reconstructPattern(patternOps) {
         ));
     }
 
-    // Literal OR pattern: multiple COMPARE_OP checks in a row
+    // Literal OR pattern: multiple COMPARE_OP checks in a row.
+    // Pattern compares share the same `left` (the matched subject). Anything
+    // with a different left is a guard expression that bled into patternOps.
     const allCompareOps = ops.filter(op => op.type === 'COMPARE');
-    if (!hasMatchSeq && allCompareOps.length > 1) {
+    const sameLeft = (a, b) => {
+        if (a === b) return true;
+        if (!a || !b) return false;
+        const af = a.codeFragment?.()?.toString?.();
+        const bf = b.codeFragment?.()?.toString?.();
+        return !!af && af === bf;
+    };
+    let patternCompareOps = allCompareOps;
+    if (allCompareOps.length > 1) {
+        const subjectLeft = allCompareOps[0].left;
+        patternCompareOps = allCompareOps.filter(op => sameLeft(op.left, subjectLeft));
+    }
+    if (!hasMatchSeq && patternCompareOps.length > 1) {
         const orPatterns = [];
-        for (const cmp of allCompareOps) {
+        for (const cmp of patternCompareOps) {
             markConsumed(cmp);
             if (cmp.right instanceof AST.ASTObject) {
                 orPatterns.push(new AST.ASTPattern(AST.ASTPattern.PatternType.Literal, cmp.right));
@@ -366,6 +380,21 @@ function hasUpcomingMatchCase() {
         return true;
     }
 
+    // `case _ as name:` final clause — CPython emits a bare STORE for the
+    // binding right after the previous case's RETURN. No LOAD precedes it
+    // (the stored value is the matched subject preserved on the stack).
+    if (this.currentMatch && this.matchSubject &&
+        (nextOpCodeId == this.OpCodes.STORE_FAST_A ||
+         nextOpCodeId == this.OpCodes.STORE_NAME_A)) {
+        const prevId = this.code.Current.OpCodeID;
+        const isAfterReturn = prevId == this.OpCodes.RETURN_VALUE ||
+                              prevId == this.OpCodes.RETURN_VALUE_A ||
+                              prevId == this.OpCodes.RETURN_CONST_A;
+        if (isAfterReturn) {
+            return true;
+        }
+    }
+
     // NOP followed by code (no COMPARE_OP) = default case (case _:)
     // This pattern appears in 3.10/3.11 after the last literal case
     if (nextOpCodeId == this.OpCodes.NOP && this.currentMatch) {
@@ -582,7 +611,10 @@ function hasUpcomingStringBuild(context) {
         context.OpCodes.STORE_DEREF_A
     ]);
 
-    for (let step = 1; step <= 12; step++) {
+    // 3.11+ inline caches inflate the physical instruction stream; a single
+    // f-string with a few interpolations easily spans 30+ code slots before
+    // reaching BUILD_STRING. Cap generously and rely on earlyStops to bound.
+    for (let step = 1; step <= 48; step++) {
         const instr = context.code.PeekInstructionAtOffset(context.code.Current.Offset + step * 2);
         if (!instr) {
             break;
@@ -745,6 +777,28 @@ function handlePopTop() {
         return;
     }
 
+    // Mid-UNPACK_SEQUENCE POP_TOP: CPython emits `a, _, b = tup` as
+    // UNPACK 3 / STORE a / POP_TOP / STORE b, where POP_TOP drops the
+    // middle slot. Our unpack-state-machine accumulates STORE targets
+    // into a tuple; treat POP_TOP as an anonymous `_` slot so the
+    // remaining STORE_FAST still sees the tuple on the stack.
+    if (this.unpack > 0) {
+        let tupleNode = this.dataStack.top();
+        if (tupleNode instanceof AST.ASTTuple) {
+            let placeholder = new AST.ASTName("_");
+            if (this.starPos-- == 0) placeholder.name = "*_";
+            tupleNode.add(placeholder);
+            if (--this.unpack <= 0) {
+                this.dataStack.pop();
+                let seqNode = this.dataStack.pop();
+                let node = new AST.ASTStore(seqNode, tupleNode);
+                node.line = this.code.Current.LineNo;
+                this.curBlock.append(node);
+            }
+            return;
+        }
+    }
+
     if ([this.OpCodes.JUMP_ABSOLUTE_A, this.OpCodes.JUMP_FORWARD_A, this.OpCodes.POP_JUMP_IF_FALSE_A, this.OpCodes.JUMP_IF_FALSE_A].includes(this.code.Prev?.OpCodeID)) {
         if (this.curBlock.blockType == AST.ASTBlock.BlockType.Except) {
             // Skipping POP_TOP, POP_TOP, POP_TOP
@@ -1111,7 +1165,15 @@ function handleReturnConstA() {
                     nextOp.OpCodeID === this.OpCodes.RERAISE;
     const prevIsPOPExcept = this.code.Prev?.OpCodeID === this.OpCodes.POP_EXCEPT;
     const nextIsSWAP = nextOp?.OpCodeID === this.OpCodes.SWAP_A;
+    const nextIsRERAISE = nextOp?.OpCodeID === this.OpCodes.RERAISE ||
+                          nextOp?.OpCodeID === this.OpCodes.RERAISE_A;
     const isExceptCleanup = isNone && prevIsPOPExcept && nextIsSWAP;
+    // CPython 3.11+ places the function's implicit `return None` at the tail of an
+    // except handler (POP_EXCEPT → RETURN_CONST None → RERAISE or end-of-function).
+    // The source has no explicit return there; drop it so the handler body doesn't
+    // inherit a phantom return.
+    const isExceptTailImplicitReturn = isNone && prevIsPOPExcept &&
+                                        (nextIsRERAISE || !nextOp);
 
     if (isNone && isModuleLevel && isAtEnd) {
         return;  // Skip implicit return None at module end
@@ -1119,6 +1181,9 @@ function handleReturnConstA() {
     if (isExceptCleanup) {
         return;  // Skip return None in exception cleanup (except* success path)
     }
+    if (isExceptTailImplicitReturn) {
+        return;  // Skip synthetic return None at end of except handler
+    }
 
     let value = new AST.ASTObject(this.code.Current.ConstantObject);
     let node = new AST.ASTReturn(value);
@@ -1294,6 +1359,12 @@ function handleInstrumentedLineA() {
     }
 }
 
+// CPython 3.13+: POP_ITER replaces the post-loop POP_TOP that discards an
+// exhausted iterator. Semantically identical to POP_TOP for our purposes.
+function handlePopIter() {
+    return handlePopTop.call(this);
+}
+
 module.exports = {
     beginMatchCaseFromPattern,
     flushCurrentCaseBody,
@@ -1302,6 +1373,7 @@ module.exports = {
     handleFormatSimple,
     handleFormatWithSpec,
     handlePopTop,
+    handlePopIter,
     handlePrintExpr,
     handlePrintItem,
     handlePrintItemTo,

package/lib/handlers/stack_ops.js

@@ -28,7 +28,8 @@ function handleDupTop() {
 
             // Look ahead to confirm match pattern immediately
             if (!this.currentMatch && this.lookAheadForMatchPattern()) {
-                this.currentMatch = new AST.ASTMatch(this.potentialMatchSubject);
+                this.matchSubject = this.potentialMatchSubject;
+                this.currentMatch = new AST.ASTMatch(this.matchSubject);
                 this.currentMatch.line = this.code.Current.LineNo;
                 this.matchParentBlock = this.curBlock;
                 this.inMatchPattern = true;  // Start tracking pattern operations
@@ -46,7 +47,8 @@ function handleDupTop() {
         if (!this.currentMatch && this.potentialMatchSubject &&
             this.object.Reader.versionCompare(3, 10) >= 0) {
             // First time - create match (fallback if look-ahead didn't work)
-            this.currentMatch = new AST.ASTMatch(this.potentialMatchSubject);
+            this.matchSubject = this.potentialMatchSubject;
+            this.currentMatch = new AST.ASTMatch(this.matchSubject);
             this.currentMatch.line = this.code.Current.LineNo;
             this.matchParentBlock = this.curBlock;
             this.inMatchPattern = true;

package/lib/handlers/unary_ops.js

@@ -69,6 +69,13 @@ function handleUnaryPositive() {
 
 function handleToBool() {
     // Python 3.13+ TO_BOOL: normalize truthiness. Preserve stack value.
+    // The preceding LOAD+COPY 1 here is the boolean-shortcut idiom for
+    // `if not X` / `while X`, not a match-case subject. Clear the
+    // potential-match candidate so a later COMPARE_OP (e.g. `e.code == 409`
+    // inside an except handler) doesn't get retroactively wrapped in a
+    // synthetic `match X:` rooted on this stale subject.
+    this.potentialMatchSubject = null;
+    this.matchCandidateStart = -1;
     const arg = this.dataStack.pop();
     this.dataStack.push(arg);
 }

package/package.json

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