depyo 1.0.2 → 1.1.0

package/lib/handlers/misc_other.js

@@ -106,7 +106,8 @@ function reconstructPattern(patternOps) {
         let attrOpsStart = ops.indexOf(matchClassOp) + 1;
         let attrOps = ops.slice(attrOpsStart);
         const unpackIndex = attrOps.findIndex(op => op.type === 'UNPACK_SEQUENCE');
-        if (unpackIndex >= 0) {
+        const hasUnpack = unpackIndex >= 0;
+        if (hasUnpack) {
             attrOps = attrOps.slice(unpackIndex + 1);
             if (unpackOp) {
                 markConsumed(unpackOp);
@@ -121,47 +122,107 @@ function reconstructPattern(patternOps) {
             attrOps = attrOps.slice(1);
         }
 
-        // Collect COMPARE / STORE_FAST operations that correspond to attributes
-        const attributeOps = [];
-        for (const op of attrOps) {
-            if (op.type === 'COMPARE' || op.type === 'STORE_FAST') {
-                attributeOps.push(op);
-                markConsumed(op);
-            }
-            if (attrCount && attributeOps.length >= attrCount) {
-                break;
+        // Two bytecode shapes for class-pattern attribute extraction:
+        //
+        //   (A) 3.11+ UNPACK_SEQUENCE shape — each attribute emits either a
+        //       COMPARE (literal) or STORE_FAST (binding) inline at its
+        //       position. SWAP 2 indicates reverseOrder across all attrs.
+        //
+        //   (B) 3.10 DUP_TOP/ROT_TWO shape — BIND_STASH marks a binding
+        //       position; its STORE_FAST appears later, after any subsequent
+        //       COMPAREs. STORE_FASTs are FIFO-matched to BIND_STASHes.
+        if (hasUnpack) {
+            const attributeOps = [];
+            for (const op of attrOps) {
+                if (op.type === 'COMPARE' || op.type === 'STORE_FAST') {
+                    attributeOps.push(op);
+                    markConsumed(op);
+                }
+                if (attrCount && attributeOps.length >= attrCount) {
+                    break;
+                }
             }
-        }
-
-        if (reverseOrder) {
-            attributeOps.reverse();
-        }
 
-        let attrIndex = 0;
-        for (const op of attributeOps) {
-            if (attrCount && attrIndex >= attrCount) {
-                break;
+            if (reverseOrder) {
+                attributeOps.reverse();
             }
 
-            if (op.type === 'COMPARE') {
-                const literalPattern = new AST.ASTPattern(
-                    AST.ASTPattern.PatternType.Literal,
-                    op.right
-                );
+            let attrIndex = 0;
+            for (const op of attributeOps) {
+                if (attrCount && attrIndex >= attrCount) {
+                    break;
+                }
                 const name = attrNames.length ? (attrNames[attrIndex] || `_attr${attrIndex}`) : null;
-                attributes.push({name, pattern: literalPattern});
-            } else if (op.type === 'STORE_FAST') {
-                const varPattern = new AST.ASTPattern(
-                    AST.ASTPattern.PatternType.Variable,
-                    op.name
-                );
-                const name = attrNames.length ? (attrNames[attrIndex] || op.name || `_attr${attrIndex}`) : null;
-                attributes.push({name, pattern: varPattern});
+                if (op.type === 'COMPARE') {
+                    attributes.push({
+                        name,
+                        pattern: new AST.ASTPattern(AST.ASTPattern.PatternType.Literal, op.right)
+                    });
+                } else {
+                    attributes.push({
+                        name,
+                        pattern: new AST.ASTPattern(AST.ASTPattern.PatternType.Variable, op.name)
+                    });
+                }
+                attrIndex++;
+            }
+        } else {
+            const inlineOps = []; // COMPARE or BIND_STASH in position order
+            const storeOps = [];  // Trailing STORE_FAST queue, FIFO to stashes
+            for (const op of attrOps) {
+                if (op.type === 'COMPARE' || op.type === 'BIND_STASH') {
+                    if (!attrCount || inlineOps.length < attrCount) {
+                        inlineOps.push(op);
+                        markConsumed(op);
+                    }
+                } else if (op.type === 'STORE_FAST') {
+                    storeOps.push(op);
+                    markConsumed(op);
+                }
             }
 
-            attrIndex++;
+            // Legacy fixtures (no BIND_STASH recorded) fall back to inline
+            // STORE_FAST handling so pre-existing Case-4-style snapshots don't
+            // regress.
+            if (inlineOps.length === 0 && storeOps.length > 0) {
+                const attributeOps = storeOps;
+                let attrIndex = 0;
+                for (const op of attributeOps) {
+                    if (attrCount && attrIndex >= attrCount) break;
+                    const name = attrNames.length ? (attrNames[attrIndex] || op.name || `_attr${attrIndex}`) : null;
+                    attributes.push({
+                        name,
+                        pattern: new AST.ASTPattern(AST.ASTPattern.PatternType.Variable, op.name)
+                    });
+                    attrIndex++;
+                }
+            } else {
+                let stashIdx = 0;
+                let attrIndex = 0;
+                for (const op of inlineOps) {
+                    if (attrCount && attrIndex >= attrCount) break;
+                    const name = attrNames.length ? (attrNames[attrIndex] || `_attr${attrIndex}`) : null;
+                    if (op.type === 'COMPARE') {
+                        attributes.push({
+                            name,
+                            pattern: new AST.ASTPattern(AST.ASTPattern.PatternType.Literal, op.right)
+                        });
+                    } else {
+                        const storeOp = storeOps[stashIdx++];
+                        attributes.push({
+                            name,
+                            pattern: storeOp
+                                ? new AST.ASTPattern(AST.ASTPattern.PatternType.Variable, storeOp.name)
+                                : new AST.ASTPattern(AST.ASTPattern.PatternType.Wildcard, '_')
+                        });
+                    }
+                    attrIndex++;
+                }
+            }
         }
 
+        let attrIndex = attributes.length;
+
         // If there are declared attributes without recorded ops, fill them with wildcards
         while (attrIndex < attrNames.length) {
             attributes.push({
@@ -521,7 +582,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;
@@ -603,6 +667,27 @@ function handlePopTop() {
             this.OpCodes.JUMP_IF_FALSE_A
         ].includes(this.code.Prev?.OpCodeID);
 
+        // A POP_TOP following ROT_TWO/ROT_THREE/ROT_FOUR is part of binding-extraction
+        // stack cleanup inside a class/sequence pattern, not the body-start POP_TOP.
+        let prevIsRot = [
+            this.OpCodes.ROT_TWO,
+            this.OpCodes.ROT_THREE,
+            this.OpCodes.ROT_FOUR
+        ].includes(this.code.Prev?.OpCodeID);
+
+        // If the next non-CACHE opcode is STORE_FAST/STORE_NAME, this POP_TOP is mid-pattern
+        // binding cleanup (pops the match result tuple before the remaining STORE captures).
+        let nextIsStoreBinding = (() => {
+            let scan = this.code.Next;
+            let steps = 0;
+            while (scan && steps < 4) {
+                if (scan.OpCodeID == this.OpCodes.CACHE) { scan = scan.Next; steps++; continue; }
+                return scan.OpCodeID == this.OpCodes.STORE_FAST_A ||
+                       scan.OpCodeID == this.OpCodes.STORE_NAME_A;
+            }
+            return false;
+        })();
+
         const patternHasOps = (this.patternOps?.length || 0) > 0;
         let isLiteralPattern = patternHasOps && !this.patternOps.some(op => ["MATCH_SEQUENCE","MATCH_CLASS","MATCH_MAPPING","MATCH_KEYS"].includes(op.type));
         let shouldStartCase = readyForWildcard || !!this.inMatchPattern;
@@ -612,6 +697,41 @@ function handlePopTop() {
         if (patternHasOps && isLiteralPattern && !prevIsJump) {
             shouldStartCase = false;
         }
+        if (patternHasOps && prevIsRot) {
+            shouldStartCase = false;
+        }
+        if (patternHasOps && nextIsStoreBinding) {
+            shouldStartCase = false;
+        }
+
+        // When readyForWildcard fires on the match-exit POP_TOP and the only
+        // code that follows is the function's implicit `return None` tail,
+        // the source didn't actually include a `case _:` clause — CPython
+        // emits the tail unconditionally. Suppress the phantom wildcard.
+        if (readyForWildcard && !patternHasOps) {
+            let scan = this.code.Next;
+            let steps = 0;
+            let sawLoadNone = false;
+            while (scan && steps < 6) {
+                const op = scan.OpCodeID;
+                if (op == this.OpCodes.CACHE ||
+                    op == this.OpCodes.RESUME_A ||
+                    op == this.OpCodes.NOP) {
+                    scan = scan.Next; steps++; continue;
+                }
+                if (op == this.OpCodes.LOAD_CONST_A && !sawLoadNone) {
+                    sawLoadNone = true;
+                    scan = scan.Next; steps++; continue;
+                }
+                if (op == this.OpCodes.RETURN_VALUE || op == this.OpCodes.RETURN_CONST_A) {
+                    if (sawLoadNone || op == this.OpCodes.RETURN_CONST_A) {
+                        shouldStartCase = false;
+                    }
+                    break;
+                }
+                break;
+            }
+        }
 
         if (shouldStartCase) {
             if (beginMatchCaseFromPattern.call(this, {reason: 'pop_top'})) {
@@ -628,7 +748,29 @@ function handlePopTop() {
         return;
     }
 
-    if (!(this.dataStack.top() instanceof AST.ASTComprehension) && [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)) {
+    // 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
             if ([this.OpCodes.JUMP_ABSOLUTE_A, this.OpCodes.JUMP_FORWARD_A].includes(this.code.Prev.OpCodeID)) {
@@ -685,7 +827,13 @@ function handlePopTop() {
     }
     if (!this.curBlock.inited) {
         if (this.curBlock.blockType == AST.ASTBlock.BlockType.With) {
+            // POP_TOP initializing a WITH block consumes the context-manager
+            // expression off the stack (Py3.0+ `with EXPR:` with no `as`).
+            // The value IS the with-expr, not a body statement — return before
+            // the fall-through append would add a phantom duplicate.
             this.curBlock.expr = value;
+            this.curBlock.init();
+            return;
         } else if (this.curBlock.blockType == AST.ASTBlock.BlockType.If && !this.curBlock.condition) {
             this.curBlock.condition = value;
         }
@@ -702,17 +850,59 @@ function handlePopTop() {
         this.curBlock.append(value);
     }
 
-    if (this.curBlock.blockType == AST.ASTBlock.BlockType.For
-            && this.curBlock.comprehension) {
-        /* This relies on some really uncertain logic...
-            * If it's a comprehension, the only POP_TOP should be
-            * a call to append the iter to the list.
-            */
-        if (value instanceof AST.ASTCall) {
+    /* Python 2.3 listcomp body uses `_[1](x)` (the cached list.append call)
+     * instead of LIST_APPEND. Detect this call, whether emitted directly in
+     * a For+comp body or nested inside if-filters (`[x for x in y if c]`),
+     * and materialize an ASTComprehension instead of leaving the call as a
+     * bogus body statement. */
+    if (value instanceof AST.ASTCall) {
+        let forBlock = null;
+        let ifBlocks = [];
+        for (let i = this.blocks.length - 1; i >= 0; i--) {
+            const blk = this.blocks[i];
+            if (blk.blockType == AST.ASTBlock.BlockType.For && blk.comprehension) {
+                forBlock = blk;
+                break;
+            }
+            if (blk.blockType == AST.ASTBlock.BlockType.If) {
+                ifBlocks.push(blk);
+            } else {
+                break;
+            }
+        }
+
+        const funcIsCompAppend = forBlock && value.func &&
+            this._listCompAppendRefs &&
+            Object.values(this._listCompAppendRefs).includes(value.func);
+        const isDirectCompBody = forBlock && this.curBlock === forBlock;
+
+        if (funcIsCompAppend || isDirectCompBody) {
             let pparams = value.pparams;
             if (!pparams.empty()) {
+                if (funcIsCompAppend && this.curBlock !== forBlock) {
+                    for (const ifBlk of ifBlocks) {
+                        let cond = ifBlk.condition;
+                        if (!cond) continue;
+                        if (ifBlk.negative) {
+                            const notCond = new AST.ASTUnary(cond, AST.ASTUnary.UnaryOp.Not);
+                            notCond.line = this.code.Current.LineNo;
+                            cond = notCond;
+                        }
+                        if (forBlock.condition) {
+                            const andCond = new AST.ASTBinary(forBlock.condition, cond, AST.ASTBinary.BinOp.LogicalAnd);
+                            andCond.line = this.code.Current.LineNo;
+                            forBlock.condition = andCond;
+                        } else {
+                            forBlock.condition = cond;
+                        }
+                    }
+                    while (this.curBlock !== forBlock && this.blocks.length > 1) {
+                        this.blocks.pop();
+                        this.curBlock = this.blocks.top();
+                    }
+                }
                 let res = pparams[0];
-                let node = new AST.ASTComprehension (res);
+                let node = new AST.ASTComprehension(res);
                 node.line = this.code.Current.LineNo;
                 this.dataStack.push(node);
             }
@@ -809,7 +999,15 @@ function handleReturnValue() {
         // Only start new case if no current case AND (not in pattern OR has unflushed pattern ops)
         const hasUnflushedPattern = (this.patternOps?.length || 0) > 0;
         const needsNewCase = !this.currentCase && (!this.inMatchPattern || hasUnflushedPattern);
-        if (needsNewCase) {
+        // Suppress phantom wildcard when this is the function-tail implicit
+        // return None: no pattern ops recorded, LOAD_CONST None precedes us,
+        // and this is the last RETURN_VALUE in the code object. CPython
+        // emits the tail whether or not source had `case _:`.
+        const topIsNone = this.dataStack.top() instanceof AST.ASTNone ||
+            (this.dataStack.top() instanceof AST.ASTObject &&
+             this.dataStack.top().obj?.ClassName === 'Py_None');
+        const isImplicitTail = !hasUnflushedPattern && topIsNone && !this.code.Next;
+        if (needsNewCase && !isImplicitTail) {
             beginMatchCaseFromPattern.call(this, {reason: 'return'});
         }
     }
@@ -938,7 +1136,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
@@ -946,6 +1152,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);

package/lib/handlers/stack_ops.js

@@ -86,17 +86,58 @@ function handleDupTop() {
                          nextOpCode == this.OpCodes.STORE_FAST_A ||
                          nextOpCode == this.OpCodes.STORE_GLOBAL_A);
 
+        // Pre-3.8 list/set/dict comprehensions compile to
+        //   BUILD_LIST 0 / DUP_TOP / STORE_NAME _[N] / ... / LIST_APPEND / ...
+        // which shares the DUP→STORE→non-STORE shape with walrus. `_[N]` is
+        // CPython's synthetic append slot, never a real identifier, so the
+        // STORE is swallowed (see processStore) and the DUP must be too —
+        // otherwise the walrus branch leaks isWalrusOperator to the next STORE
+        // (the FOR_ITER's iteration variable), stealing its valueNode.
+        let nextName = this.code.Next?.Name || "";
+        if (isStoreOp && nextName.length >= 2 && nextName.startsWith('_[')) {
+            return;
+        }
+
         if (isStoreOp && this.code.Next?.Next) {
-            let afterStoreOpCode = this.code.Next.Next.OpCodeID;
-            let isAnotherStore = (afterStoreOpCode == this.OpCodes.STORE_NAME_A ||
-                                  afterStoreOpCode == this.OpCodes.STORE_FAST_A ||
-                                  afterStoreOpCode == this.OpCodes.STORE_GLOBAL_A ||
-                                  afterStoreOpCode == this.OpCodes.STORE_ATTR_A ||
-                                  afterStoreOpCode == this.OpCodes.STORE_DEREF_A);
-
-            if (!isAnotherStore) {
-                // This is a walrus operator (named expression)
-                // Don't duplicate - just set flag. The value will be wrapped in ASTNamedExpr.
+            // Chain assign and nested walrus share the shape
+            //   (DUP STORE)+  ending either with STORE (chain, statement)
+            //                  or STORE / POP_TOP (walrus, expression).
+            // Walk forward over the alternating DUP/STORE run and inspect
+            // what follows the last STORE to distinguish them.
+            const storeOps = new Set([
+                this.OpCodes.STORE_NAME_A,
+                this.OpCodes.STORE_FAST_A,
+                this.OpCodes.STORE_GLOBAL_A,
+                this.OpCodes.STORE_ATTR_A,
+                this.OpCodes.STORE_DEREF_A
+            ]);
+            const instructions = this.code.Instructions;
+            let idx = this.code.CurrentInstructionIndex + 1; // at STORE
+            let lastStoreIdx = -1;
+            let storeCount = 0;
+            while (idx < instructions.length) {
+                const op = instructions[idx].OpCodeID;
+                if (storeOps.has(op)) {
+                    lastStoreIdx = idx;
+                    storeCount++;
+                    idx++;
+                } else if (op == this.OpCodes.DUP_TOP) {
+                    idx++;
+                } else {
+                    break;
+                }
+            }
+            const afterRunOp = lastStoreIdx >= 0
+                ? instructions[lastStoreIdx + 1]?.OpCodeID
+                : undefined;
+            // Chain assign needs 2+ STOREs; single-STORE runs are walrus
+            // regardless of what follows.
+            const isChainAssign = storeCount >= 2 &&
+                                  afterRunOp !== undefined &&
+                                  afterRunOp !== this.OpCodes.POP_TOP;
+
+            if (!isChainAssign) {
+                // Nested walrus operator — mark this DUP as walrus-producing.
                 this.isWalrusOperator = true;
                 return;
             }
@@ -210,6 +251,19 @@ function handleSwapA() {
 }
 
 function handleRotTwo() {
+    // In Py3.10 match/case, ROT_TWO plays two roles:
+    //   1. Sequence-pattern element-order reversal (follows UNPACK_SEQUENCE)
+    //      → record SWAP so reconstructPattern's reverseOrder kicks in.
+    //   2. Class-pattern binding-extraction dance (follows BINARY_SUBSCR)
+    //      → record BIND_STASH so reconstructPattern can place the later
+    //        STORE_FAST at the correct attribute position.
+    if (this.inMatchPattern) {
+        if (this.code.Prev?.OpCodeID == this.OpCodes.UNPACK_SEQUENCE_A) {
+            this.patternOps.push({type: 'SWAP', depth: 2});
+        } else if (this.code.Prev?.OpCodeID == this.OpCodes.BINARY_SUBSCR) {
+            this.patternOps.push({type: 'BIND_STASH'});
+        }
+    }
     let one = this.dataStack.pop();
     if (this.dataStack.top() instanceof AST.ASTChainStore) {
         this.dataStack.pop();
@@ -221,18 +275,26 @@ function handleRotTwo() {
 }
 
 function handleRotThree() {
-        let one = this.dataStack.pop();
-        let two = this.dataStack.pop();
-        if (this.dataStack.top() instanceof AST.ASTChainStore) {
-            this.dataStack.pop();
-        }
-        let three = this.dataStack.pop();
-        this.dataStack.push(one);
-        this.dataStack.push(three);
-        this.dataStack.push(two);
+    if (this.inMatchPattern &&
+        this.code.Prev?.OpCodeID == this.OpCodes.BINARY_SUBSCR) {
+        this.patternOps.push({type: 'BIND_STASH'});
+    }
+    let one = this.dataStack.pop();
+    let two = this.dataStack.pop();
+    if (this.dataStack.top() instanceof AST.ASTChainStore) {
+        this.dataStack.pop();
     }
+    let three = this.dataStack.pop();
+    this.dataStack.push(one);
+    this.dataStack.push(three);
+    this.dataStack.push(two);
+}
 
 function handleRotFour() {
+    if (this.inMatchPattern &&
+        this.code.Prev?.OpCodeID == this.OpCodes.BINARY_SUBSCR) {
+        this.patternOps.push({type: 'BIND_STASH'});
+    }
     let one = this.dataStack.pop();
     let two = this.dataStack.pop();
     let three = this.dataStack.pop();

package/lib/handlers/subscript_slice.js

@@ -25,6 +25,26 @@ function handleMapAddA() {
         return;
     }
 
+    // Async dict comprehension inner code: GET_ANEXT iteration uses
+    // SETUP_EXCEPT/FINALLY rather than FOR_ITER, so no For+comp block
+    // exists. Save the key/value so the CALL-site reconstruction can use
+    // them as the comprehension's yield expression.
+    let forBlock = null;
+    for (let i = this.blocks.length - 1; i >= 0; i--) {
+        const blk = this.blocks[i];
+        if (blk.blockType == AST.ASTBlock.BlockType.For && blk.comprehension) {
+            forBlock = blk;
+            break;
+        }
+        if (blk.blockType != AST.ASTBlock.BlockType.If) {
+            break;
+        }
+    }
+    if (!forBlock) {
+        this.object._asyncCompYieldExpr = value;
+        this.object._asyncCompYieldKey = key;
+    }
+
     let mapNode = this.dataStack.pop();
 
     if (!(mapNode instanceof AST.ASTMap)) {
@@ -38,7 +58,23 @@ function handleMapAddA() {
 }
 
 function handleStoreMap() {
-    handleBuildSliceA.call(this);
+    // Py2.x STORE_MAP: TOS=key, SECOND=value, THIRD=dict under construction.
+    // Pops key and value, leaves dict on stack with entry added.
+    // Without this, BUILD_MAP yields an empty ASTMap and the raw key/value
+    // LOAD_CONSTs pile onto the stack; the trailing STORE_NAME then picks
+    // up the last-pushed key (a literal int/string) instead of the dict.
+    let key = this.dataStack.pop();
+    let value = this.dataStack.pop();
+    let mapNode = this.dataStack.top();
+    if (mapNode instanceof AST.ASTMap) {
+        mapNode.add(key, value);
+        mapNode.line = this.code.Current.LineNo;
+    } else {
+        // No dict under construction — unexpected; restore stack so downstream
+        // handlers still see the values and can diagnose the shape.
+        this.dataStack.push(value);
+        this.dataStack.push(key);
+    }
 }
 
 function handleBuildSliceA() {
@@ -297,6 +333,70 @@ function storeMatchesAnnotation(storeNode, annotationKeyNode) {
     return false;
 }
 
+function handleBinarySlice() {
+    // Python 3.12+ BINARY_SLICE: (container, start, stop -- container[start:stop])
+    let stop = this.dataStack.pop();
+    let start = this.dataStack.pop();
+    let container = this.dataStack.pop();
+
+    if (start instanceof AST.ASTObject && (start.object == null || start.object.ClassName == 'Py_None')) {
+        start = null;
+    }
+    if (stop instanceof AST.ASTObject && (stop.object == null || stop.object.ClassName == 'Py_None')) {
+        stop = null;
+    }
+
+    let sliceOp;
+    if (!start && !stop) {
+        sliceOp = AST.ASTSlice.SliceOp.Slice0;
+    } else if (!start) {
+        sliceOp = AST.ASTSlice.SliceOp.Slice2;
+    } else if (!stop) {
+        sliceOp = AST.ASTSlice.SliceOp.Slice1;
+    } else {
+        sliceOp = AST.ASTSlice.SliceOp.Slice3;
+    }
+
+    let sliceNode = new AST.ASTSlice(sliceOp, start, stop);
+    sliceNode.line = this.code.Current.LineNo;
+    let node = new AST.ASTSubscr(container, sliceNode);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
+function handleStoreSlice() {
+    // Python 3.12+ STORE_SLICE: (value, container, start, stop -- )
+    // Stores container[start:stop] = value
+    let stop = this.dataStack.pop();
+    let start = this.dataStack.pop();
+    let container = this.dataStack.pop();
+    let value = this.dataStack.pop();
+
+    if (start instanceof AST.ASTObject && (start.object == null || start.object.ClassName == 'Py_None')) {
+        start = null;
+    }
+    if (stop instanceof AST.ASTObject && (stop.object == null || stop.object.ClassName == 'Py_None')) {
+        stop = null;
+    }
+
+    let sliceOp;
+    if (!start && !stop) {
+        sliceOp = AST.ASTSlice.SliceOp.Slice0;
+    } else if (!start) {
+        sliceOp = AST.ASTSlice.SliceOp.Slice2;
+    } else if (!stop) {
+        sliceOp = AST.ASTSlice.SliceOp.Slice1;
+    } else {
+        sliceOp = AST.ASTSlice.SliceOp.Slice3;
+    }
+
+    let sliceNode = new AST.ASTSlice(sliceOp, start, stop);
+    sliceNode.line = this.code.Current.LineNo;
+    let node = new AST.ASTStore(value, new AST.ASTSubscr(container, sliceNode));
+    node.line = this.code.Current.LineNo;
+    this.curBlock.append(node);
+}
+
 function handleStoreSubscr() {
     if (this.unpack) {
         let subscrNode = this.dataStack.pop();
@@ -390,5 +490,7 @@ module.exports = {
     handleStoreSlice1,
     handleStoreSlice2,
     handleStoreSlice3,
+    handleBinarySlice,
+    handleStoreSlice,
     handleStoreSubscr,
 };