depyo 1.0.2 → 1.1.0

package/lib/handlers/load_store_names.js

@@ -22,7 +22,12 @@ function handleDeleteNameA() {
     }
 
     if (varname.length >= 2 && varname.startsWith('_[')) {
-        /* Don't show deletes that are a result of list comps. */
+        /* Don't show deletes that are a result of list comps.
+         * Clear the _listCompAppendRefs cache so the next FOR_ITER outside
+         * this listcomp doesn't mistake itself for one. */
+        if (this._listCompAppendRefs) {
+            delete this._listCompAppendRefs[varname];
+        }
         return;
     }
 
@@ -39,7 +44,12 @@ function handleDeleteFastA() {
     let nameNode = new AST.ASTName(nameVal);
 
     if (nameNode.name.startsWith('_[')) {
-        /* Don't show deletes that are a result of list comps. */
+        /* Don't show deletes that are a result of list comps.
+         * Clear the _listCompAppendRefs cache so the next FOR_ITER outside
+         * this listcomp doesn't mistake itself for one. */
+        if (this._listCompAppendRefs) {
+            delete this._listCompAppendRefs[nameNode.name];
+        }
         return;
     }
 
@@ -112,6 +122,10 @@ function handleLoadClassderefA() {
 function processLoadDeref() {
     let varName = this.code.Current.FreeName || "";
     if (varName.length >= 2 && varName.startsWith('_[')) {
+        const cached = this._listCompAppendRefs?.[varName];
+        if (cached) {
+            this.dataStack.push(cached);
+        }
         return;
     }
     let node = new AST.ASTName (varName);
@@ -122,6 +136,14 @@ function processLoadDeref() {
 function handleLoadFastA() {
     let varName = this.code.Current.Name || "";
     if (varName.length >= 2 && varName.startsWith('_[')) {
+        // Pre-LIST_APPEND comprehensions (Python 2.3) cache `list.append` in
+        // the synthetic `_[N]` slot and re-load it to call per iteration.
+        // Replay the stored expression so CALL_FUNCTION has a real callable
+        // instead of falling through to `##ERROR##`.
+        const cached = this._listCompAppendRefs?.[varName];
+        if (cached) {
+            this.dataStack.push(cached);
+        }
         return;
     }
 
@@ -138,6 +160,10 @@ function handleLoadFastCheckA() {
 function handleLoadGlobalA() {
     let varName = this.code.Current.Name || "";
     if (varName.length >= 2 && varName.startsWith('_[')) {
+        const cached = this._listCompAppendRefs?.[varName];
+        if (cached) {
+            this.dataStack.push(cached);
+        }
         return;
     }
 
@@ -157,8 +183,15 @@ function handleLoadGlobalA() {
 }
 
 function handleLoadFromDictOrDerefA() {
-    // Python 3.12+: load from locals dict or closure; approximate as a normal name load.
-    const varName = this.code.Current.Name || "";
+    // Python 3.12+: LOAD_FROM_DICT_OR_DEREF consumes the locals dict from TOS
+    // (pushed by the preceding LOAD_LOCALS) and resolves the name against it,
+    // falling back to the deref cell. The argument is a localsplus index into
+    // [VarNames | CellVars | FreeVars] — use FreeName which the opcode reader
+    // resolved via that table.
+    if (this.dataStack.top() instanceof AST.ASTLocals) {
+        this.dataStack.pop();
+    }
+    const varName = this.code.Current.FreeName || this.code.Current.Name || "";
     if (!varName.length) {
         return;
     }
@@ -188,6 +221,10 @@ function handleLoadMethodA() {
 function handleLoadNameA() {
     let varName = this.code.Current.Name || "";
     if (varName.length >= 2 && varName.startsWith('_[')) {
+        const cached = this._listCompAppendRefs?.[varName];
+        if (cached) {
+            this.dataStack.push(cached);
+        }
         return;
     }
     let node = new AST.ASTName (varName);
@@ -349,9 +386,30 @@ function handleStoreDerefA() {
             }
         }
     } else {
-        let valueNode = this.dataStack.pop();
         let nameNode = new AST.ASTName(this.code.Current.FreeName);
 
+        // Closure-captured for-loop variable: STORE_DEREF to a cell var while an
+        // uninitialized For block is on the stack means this is the loop index,
+        // not an assignment. Py 3.0 classes with decorators closing over the
+        // loop variable use this pattern (STORE_DEREF for the captured name,
+        // STORE_FAST for the class afterwards).
+        let parentForBlock = null;
+        for (let i = this.blocks.length - 1; i >= 0; i--) {
+            if ((this.blocks[i].blockType == AST.ASTBlock.BlockType.For ||
+                 this.blocks[i].blockType == AST.ASTBlock.BlockType.AsyncFor) &&
+                !this.blocks[i].inited) {
+                parentForBlock = this.blocks[i];
+                break;
+            }
+        }
+        if (parentForBlock) {
+            parentForBlock.index = nameNode;
+            parentForBlock.init();
+            return;
+        }
+
+        let valueNode = this.dataStack.pop();
+
         if (valueNode instanceof AST.ASTChainStore) {
             this.append_to_chain_store(valueNode, nameNode);
         } else {
@@ -374,13 +432,41 @@ function handleStoreNameA() {
     processStore.call(this);
 }
 
-function processStore() {
+function handleStoreAnnotationA() {
+    // Python 3.6 only: pops the annotation type and stores it under
+    // __annotations__[name]. The variable name is the opcode argument.
+    // Patterns:
+    //   `x: int`        → LOAD_NAME int ; STORE_ANNOTATION x
+    //   `x: int = 1`    → LOAD_CONST 1 ; STORE_NAME x ; LOAD_NAME int ; STORE_ANNOTATION x
+    const annType = this.dataStack.pop();
+    const varName = this.code.Current.Name || "";
+    const nameNode = new AST.ASTName(varName);
+
+    const last = this.curBlock.nodes.top();
+    if (last instanceof AST.ASTStore &&
+        last.dest instanceof AST.ASTName &&
+        last.dest.name === varName) {
+        // Combine prior `x = value` with annotation → `x: int = value`
+        const annotated = new AST.ASTAnnotatedVar(nameNode, annType);
+        annotated.line = this.code.Current.LineNo;
+        last.dest = annotated;
+    } else {
+        // Standalone annotation `x: int`
+        const annotated = new AST.ASTAnnotatedVar(nameNode, annType);
+        annotated.line = this.code.Current.LineNo;
+        this.curBlock.append(annotated);
+    }
+}
+
+function processStore(nameOverride) {
+    const currentName = nameOverride !== undefined ? nameOverride : this.code.Current.Name;
+
     // Pattern matching: first capture expected bindings, then start case body
     if (this.inMatchPattern) {
         if (shouldCaptureStoreInPattern(this.patternOps)) {
             this.patternOps.push({
                 type: 'STORE_FAST',
-                name: this.code.Current.Name
+                name: currentName
             });
             return;
         }
@@ -392,8 +478,8 @@ function processStore() {
         }
     }
 
-    if (global.g_cliArgs?.debug && this.code.Current.Name && (this.code.Current.Name === 'b' || this.code.Current.Name === 'i')) {
-        console.log(`[processStore] varName=${this.code.Current.Name}, curBlock=${this.curBlock.type_str}, inited=${this.curBlock.inited}, unpack=${this.unpack}`);
+    if (global.g_cliArgs?.debug && currentName && (currentName === 'b' || currentName === 'i')) {
+        console.log(`[processStore] varName=${currentName}, curBlock=${this.curBlock.type_str}, inited=${this.curBlock.inited}, unpack=${this.unpack}`);
         console.log(`  Block stack: ${this.blocks.map((b,i) => `[${i}]${b.type_str}(inited=${b.inited})`).join(' → ')}`);
     }
 
@@ -409,7 +495,7 @@ function processStore() {
     }
 
     if (this.unpack) {
-        let nameNode = new AST.ASTName(this.code.Current.Name);
+        let nameNode = new AST.ASTName(currentName);
 
         let tupleNode = this.dataStack.top();
         if (tupleNode instanceof AST.ASTTuple) {
@@ -444,9 +530,28 @@ function processStore() {
             }
         }
     } else {
-        let varName = this.code.Current.Name || "";
+        let varName = currentName || "";
         if (varName.length >= 2 && varName.startsWith('_[')) {
-            /* Don't show stores of list comp append objects. */
+            /* Synthetic `_[N]` is CPython bookkeeping; never in real source.
+             * Listcomp case: Py2.3 stores `list.append`, Py2.4-2.6 stores
+             *   the list itself. Pop + cache so later LOAD can replay.
+             * Pre-PEP-343 `with` (2.5+) also uses `_[N]` to park __exit__ /
+             *   __enter__() result. Those are consumed by downstream opcodes
+             *   walking the stack backwards — we must NOT pop in that case.
+             * Heuristic: if stack top matches listcomp shape, swallow. Else
+             * leave stack untouched so the with-handler's backward scan still
+             * sees the real expressions. */
+            const top = this.dataStack[this.dataStack.length - 1];
+            const isListcompList = top instanceof AST.ASTList;
+            const isListcompAppend = top instanceof AST.ASTBinary
+                && top.op === AST.ASTBinary.BinOp.Attr
+                && top.right instanceof AST.ASTName
+                && top.right.name === "append";
+            if (isListcompList || isListcompAppend) {
+                this.dataStack.pop();
+                this._listCompAppendRefs = this._listCompAppendRefs || {};
+                this._listCompAppendRefs[varName] = top;
+            }
             return;
         }
 
@@ -477,6 +582,23 @@ function processStore() {
             parentForBlock.init();
         } else {
             let valueNode = this.dataStack.pop();
+            // DUP_TOP for chain assign leaves [V, V, ChainStore] on the
+            // stack, so the ChainStore is popped here as `valueNode` rather
+            // than being the second-from-top importNode checked below.
+            if (valueNode instanceof AST.ASTChainStore) {
+                this.dataStack.pop(); // consume the extra duplicate V
+                this.append_to_chain_store(valueNode, nameNode);
+                if (this.code.Prev?.OpCodeID != this.OpCodes.DUP_TOP &&
+                    this.code.Prev?.OpCodeID != this.OpCodes.COPY_A) {
+                    // Terminal store — commit chainstore to block and
+                    // clear the copy append_to_chain_store just pushed.
+                    if (this.dataStack.top() === valueNode) {
+                        this.dataStack.pop();
+                    }
+                    this.curBlock.append(valueNode);
+                }
+                return;
+            }
             let importNode = this.dataStack.top();
             if (importNode instanceof AST.ASTImport) {
                 let storeNode = new AST.ASTStore(valueNode, nameNode);
@@ -505,6 +627,7 @@ function processStore() {
             if (valueNode instanceof AST.ASTFunction && !valueNode.code.object.SourceCode) {
                 let decompiler = new PycDecompiler(valueNode.code.object);
                 valueNode.code.object.SourceCode = decompiler.decompile();
+                if (decompiler.errors.length) this.errors.push(...decompiler.errors);
             }
             let lastBlockNode = this.curBlock.nodes.top();
             if (
@@ -564,9 +687,25 @@ function handleReserveFastA() {
 }
 
 function handleLoadFastAndClearA() {
-    // Python 3.11+ LOAD_FAST_AND_CLEAR - loads local and clears it
-    // Used in comprehensions to save/restore outer scope variables
-    // For decompilation: just load the variable (clearing is implementation detail)
+    // Python 3.12+ inline comprehension save pattern:
+    //   LOAD_FAST_AND_CLEAR var ; SWAP 2 ; BUILD_<LIST|SET|MAP> 0 ; SWAP 2 ; (GET_ITER)? ; FOR_ITER
+    // CPython inlines comprehensions into the parent scope, saving the loop var
+    // before and restoring after. Skip the save here so the comprehension stack
+    // matches the simpler BUILD/SWAP/GET_ITER/FOR_ITER shape; END_FOR cleans up.
+    const next1 = this.code.Next;
+    const next2 = next1?.Next;
+    const next3 = next2?.Next;
+    const isCompStart = next1?.OpCodeID == this.OpCodes.SWAP_A && next1.Argument == 2 &&
+                        (next2?.OpCodeID == this.OpCodes.BUILD_LIST_A ||
+                         next2?.OpCodeID == this.OpCodes.BUILD_SET_A ||
+                         next2?.OpCodeID == this.OpCodes.BUILD_MAP_A) &&
+                        next2.Argument == 0 &&
+                        next3?.OpCodeID == this.OpCodes.SWAP_A && next3.Argument == 2;
+    if (isCompStart) {
+        this._inlineCompSavedVar = this.code.Current.Name;
+        this.code.GoNext(); // consume the SWAP 2 right after this op
+        return;
+    }
     handleLoadFastA.call(this);
 }
 
@@ -575,6 +714,11 @@ function handleLoadFastBorrowA() {
     handleLoadFastA.call(this);
 }
 
+function handleLoadFastBorrowLoadFastBorrowA() {
+    // Python 3.15+ packed borrow load (same encoding as LOAD_FAST_LOAD_FAST).
+    handleLoadFastLoadFastA.call(this);
+}
+
 function handleLoadCommonConstantA() {
     // Python 3.14+ common constants table
     const {PythonObject} = require('../PythonObject');
@@ -597,70 +741,57 @@ function handleLoadCommonConstantA() {
 }
 
 function handleLoadFastLoadFastA() {
-    // Combined load of two fast locals: arg packs (hi<<8)|lo
+    // CPython pushes local[hi] then local[lo]. For 3.13 the two halves are packed
+    // nibble-wise in the argument (hi in upper nibble, lo in lower nibble);
+    // older bytecode used bytes.
     const packed = this.code.Current.Argument;
     const isPackedNibbles = this.object?.Reader?.versionCompare(3, 13) >= 0;
-    const idx1 = isPackedNibbles ? ((packed) & 0x0F) : (packed & 0xFF);
-    const idx2 = isPackedNibbles ? ((packed >> 4) & 0x0F) : ((packed >> 8) & 0xFF);
+    const hiIdx = isPackedNibbles ? ((packed >> 4) & 0x0F) : ((packed >> 8) & 0xFF);
+    const loIdx = isPackedNibbles ? (packed & 0x0F) : (packed & 0xFF);
     const varNames = this.object?.VarNames?.Value || this.object?.code?.object?.VarNames?.Value || [];
-    const name1 = varNames[idx1]?.toString?.() || `##var_${idx1}##`;
-    const name2 = varNames[idx2]?.toString?.() || `##var_${idx2}##`;
-    // Preserve operand order expected by STORE_ATTR sequences: lower nibble first
-    this.dataStack.push(new AST.ASTName(name1));
-    this.dataStack.push(new AST.ASTName(name2));
+    const hiName = varNames[hiIdx]?.toString?.() || `##var_${hiIdx}##`;
+    const loName = varNames[loIdx]?.toString?.() || `##var_${loIdx}##`;
+    this.dataStack.push(new AST.ASTName(hiName));
+    this.dataStack.push(new AST.ASTName(loName));
 }
 
 function handleStoreFastLoadFastA() {
-    // Combined store then load: store to first index, load second
+    // CPython: store TOS into local[hi], then push local[lo].
     const packed = this.code.Current.Argument;
     const isPackedNibbles = this.object?.Reader?.versionCompare(3, 13) >= 0;
-    const idx1 = isPackedNibbles ? (packed & 0x0F) : (packed & 0xFF);
-    const idx2 = isPackedNibbles ? ((packed >> 4) & 0x0F) : ((packed >> 8) & 0xFF);
+    const storeIdx = isPackedNibbles ? ((packed >> 4) & 0x0F) : ((packed >> 8) & 0xFF);
+    const loadIdx = isPackedNibbles ? (packed & 0x0F) : (packed & 0xFF);
     const varNames = this.object?.VarNames?.Value || this.object?.code?.object?.VarNames?.Value || [];
-    const name1 = varNames[idx1]?.toString?.() || `##var_${idx1}##`;
-    const name2 = varNames[idx2]?.toString?.() || `##var_${idx2}##`;
+    const storeName = varNames[storeIdx]?.toString?.() || `##var_${storeIdx}##`;
+    const loadName = varNames[loadIdx]?.toString?.() || `##var_${loadIdx}##`;
 
     if (this.inMatchPattern && shouldCaptureStoreInPattern(this.patternOps)) {
-        // Capture binding and surface loaded local for guards
         this.dataStack.pop();
-        this.patternOps.push({type: 'STORE_FAST', name: name1});
-        this.dataStack.push(new AST.ASTName(name2));
+        this.patternOps.push({type: 'STORE_FAST', name: storeName});
+        this.dataStack.push(new AST.ASTName(loadName));
         return;
     }
 
-    const valueNode = this.dataStack.pop() || new AST.ASTNone();
-    const destNode = new AST.ASTName(name1);
-    this.curBlock.append(new AST.ASTStore(valueNode, destNode));
-
-    // Push second local load as result
-    this.dataStack.push(new AST.ASTName(name2));
+    // Route STORE through processStore so for-block target / unpack / chain-store work.
+    processStore.call(this, storeName);
+    this.dataStack.push(new AST.ASTName(loadName));
 }
 
 function handleStoreFastStoreFastA() {
-    // Combined store to two locals: arg packs (hi<<8)|lo
+    // CPython: stack is [value2, value1] with value1 on TOS.
+    // SETLOCAL(hi, value1); SETLOCAL(lo, value2).
     const packed = this.code.Current.Argument;
     const isPackedNibbles = this.object?.Reader?.versionCompare(3, 13) >= 0;
-    const idx1 = isPackedNibbles ? (packed & 0x0F) : (packed & 0xFF);
-    const idx2 = isPackedNibbles ? ((packed >> 4) & 0x0F) : ((packed >> 8) & 0xFF);
+    const hiIdx = isPackedNibbles ? ((packed >> 4) & 0x0F) : ((packed >> 8) & 0xFF);
+    const loIdx = isPackedNibbles ? (packed & 0x0F) : (packed & 0xFF);
     const varNames = this.object?.VarNames?.Value || this.object?.code?.object?.VarNames?.Value || [];
-    const name1 = varNames[idx1]?.toString?.() || `##var_${idx1}##`;
-    const name2 = varNames[idx2]?.toString?.() || `##var_${idx2}##`;
-
-    if (this.inMatchPattern && shouldCaptureStoreInPattern(this.patternOps)) {
-        // Record bindings in pattern order (high nibble corresponds to first element)
-        this.dataStack.pop(); // second element
-        this.dataStack.pop(); // first element
-        this.patternOps.push({type: 'STORE_FAST', name: name2});
-        this.patternOps.push({type: 'STORE_FAST', name: name1});
-        return;
-    }
-
-    const value2 = this.dataStack.pop() || new AST.ASTNone();
-    const value1 = this.dataStack.pop() || new AST.ASTNone();
+    const hiName = varNames[hiIdx]?.toString?.() || `##var_${hiIdx}##`;
+    const loName = varNames[loIdx]?.toString?.() || `##var_${loIdx}##`;
 
-    // First store lower nibble value (top of stack), then higher nibble
-    this.curBlock.append(new AST.ASTStore(value2, new AST.ASTName(name1)));
-    this.curBlock.append(new AST.ASTStore(value1, new AST.ASTName(name2)));
+    // Delegate to processStore so unpack / for-target / chain-store paths work.
+    // First store consumes TOS (high nibble target), second store consumes new TOS.
+    processStore.call(this, hiName);
+    processStore.call(this, loName);
 }
 
 function handleLoadSmallIntA() {
@@ -686,6 +817,7 @@ module.exports = {
     handleLoadFastCheckA,
     handleLoadFastAndClearA,
     handleLoadFastBorrowA,
+    handleLoadFastBorrowLoadFastBorrowA,
     handleLoadFastLoadFastA,
     handleLoadGlobalA,
     handleLoadCommonConstantA,
@@ -707,5 +839,6 @@ module.exports = {
     handleStoreFastStoreFastA,
     handleStoreGlobalA,
     handleStoreNameA,
+    handleStoreAnnotationA,
     handleReserveFastA
 };

package/lib/handlers/loop_iterator.js

@@ -55,6 +55,7 @@ function handleInstrumentedForIterA() {
     let end = 0;
     let line = this.code.Current.LineNo;
     let comprehension = false;
+    let pre38ListCompDetected = false;
     const specialized = this.object.Reader.versionCompare(3, 13) >= 0;
     const sentinel = specialized ? new AST.ASTNone() : null;
 
@@ -79,6 +80,23 @@ function handleInstrumentedForIterA() {
                 comprehension = true;
             }
         }
+        // 3.12+ inline comprehension: extend block end past END_FOR so the
+        // for-block isn't auto-popped before handleEndFor runs the cleanup.
+        // Without this, the auto-pop at PycDecompiler.js:614 closes the
+        // for-block at its natural end (just past JUMP_BACKWARD), and END_FOR
+        // can't reach it to call addGenerator.
+        if (this._inlineCompSavedVar != null && comprehension) {
+            let scanOff = end;
+            for (let i = 0; i < 10; i++) {
+                const ins = this.code.PeekInstructionAtOffset(scanOff);
+                if (!ins) break;
+                if (ins.OpCodeID == this.OpCodes.END_FOR) {
+                    end = ins.Offset + (ins.Size || 2);
+                    break;
+                }
+                scanOff += (ins.Size || 2);
+            }
+        }
     } else {
         if ((this.dataStack.top() instanceof AST.ASTSet ||
             this.dataStack.top() instanceof AST.ASTList ||
@@ -86,6 +104,72 @@ function handleInstrumentedForIterA() {
             && this.dataStack.top().values.length == 0) {
             end = this.code.Current.JumpTarget;
             comprehension = true;
+            // 2.7 inline listcomp (no `_[N]` cache, empty ASTList on stack):
+            // LIST_APPEND arg=N reads the accumulator via peek-offset, so the
+            // sentinel push would leave the real accumulator trapped on the
+            // stack for the trailing COMPARE_OP / etc. to swallow as a
+            // phantom operand. Skip the sentinel and let LIST_APPEND pop the
+            // accumulator directly.
+            // Dict/set comps (ASTMap/ASTSet): MAP_ADD/SET_ADD pop one entry
+            // assuming the sentinel is present — keep the sentinel there.
+            // 2.3-2.6 with `_[N]` cache: handled by the else-if below (top
+            // of stack is the enclosing expression, not an empty list).
+            // Exception: if the body has UNPACK_SEQUENCE (loop var is a
+            // tuple `for k, v in …`), the STORE chain's final seqNode pop
+            // would consume the accumulator list instead of a sentinel,
+            // stranding the outer callable (e.g. `dict`) on the stack for
+            // LIST_APPEND to eat as the "list". Keep the sentinel so STORE
+            // consumes it and LIST_APPEND still finds the real accumulator.
+            const hasListcompCache = this._listCompAppendRefs
+                && Object.keys(this._listCompAppendRefs).length > 0;
+            const isList = this.dataStack.top() instanceof AST.ASTList;
+            if (!hasListcompCache && isList) {
+                let hasUnpackInBody = false;
+                const bodyEnd = this.code.Current.JumpTarget;
+                let scanOff = this.code.Next?.Offset;
+                for (let i = 0; i < 20 && scanOff != null && scanOff < bodyEnd; i++) {
+                    const ins = this.code.PeekInstructionAtOffset(scanOff);
+                    if (!ins) break;
+                    if (ins.OpCodeID === this.OpCodes.UNPACK_SEQUENCE_A) {
+                        hasUnpackInBody = true;
+                        break;
+                    }
+                    scanOff = ins.Offset + (ins.Size || 3);
+                }
+                if (!hasUnpackInBody) {
+                    pre38ListCompDetected = true;
+                }
+            }
+        } else if (this._listCompAppendRefs && Object.keys(this._listCompAppendRefs).length > 0) {
+            // Py2.4-2.6 inline listcomp: accumulator stashed in `_[N]` via
+            // DUP_TOP/STORE_NAME, so the empty-list heuristic misses it
+            // (stack top is the enclosing expression — `dict` for
+            // `dict([…])`, or the COMPARE_OP left-list for `assert X == […]`).
+            // Body always does `LOAD _[N]` before LIST_APPEND, so the
+            // accumulator reaches LIST_APPEND via the cache and the sentinel
+            // survives. When the loop var is stored via plain STORE_NAME
+            // (parentForBlock path, no pop), nothing consumes the sentinel
+            // and it leaks into the trailing COMPARE_OP / CALL_FUNCTION.
+            // Look ahead for UNPACK_SEQUENCE in the body: if present, the
+            // STORE chain consumes the sentinel as its seqNode pop — keep
+            // it. Otherwise skip the sentinel push.
+            end = this.code.Current.JumpTarget;
+            comprehension = true;
+            let hasUnpackInBody = false;
+            const bodyEnd = this.code.Current.JumpTarget;
+            let scanOff = this.code.Next?.Offset;
+            for (let i = 0; i < 20 && scanOff != null && scanOff < bodyEnd; i++) {
+                const ins = this.code.PeekInstructionAtOffset(scanOff);
+                if (!ins) break;
+                if (ins.OpCodeID === this.OpCodes.UNPACK_SEQUENCE_A) {
+                    hasUnpackInBody = true;
+                    break;
+                }
+                scanOff = ins.Offset + (ins.Size || 3);
+            }
+            if (!hasUnpackInBody) {
+                pre38ListCompDetected = true;
+            }
         } else {
             let top = this.blocks.top();
             start = top.start;
@@ -94,6 +178,12 @@ function handleInstrumentedForIterA() {
 
             if (top.blockType == AST.ASTBlock.BlockType.While) {
                 this.blocks.pop();
+                // Py2.4-2.6 genexpr inner code has SETUP_LOOP → While, but
+                // it IS a comprehension. Detect by code object name.
+                const objName = this.object?.Name;
+                if (objName === "<generator expression>" || objName === "<genexpr>") {
+                    comprehension = true;
+                }
             } else {
                 comprehension = true;
             }
@@ -104,15 +194,18 @@ function handleInstrumentedForIterA() {
     forblk.line = line;
     forblk.comprehension = comprehension;
 
-    if (global.g_cliArgs?.debug) {
-        console.log(`[FOR_ITER] Created for block: start=${start}, end=${end}, comprehension=${comprehension}`);
-    }
-
     this.blocks.push(forblk);
     this.curBlock = this.blocks.top();
 
-    // 3.13+ FOR_ITER pushes a sentinel used by END_FOR; keep stack balanced.
-    this.dataStack.push(sentinel);
+    // Py2.6 inline listcomp (detected via _[N] cache) has no POP_TOP at the
+    // for-block end to consume the sentinel — the enclosing COMPARE_OP/etc
+    // would then swallow it as a fake operand. Skip the placeholder push in
+    // that case; nothing downstream needs it since the comprehension closes
+    // at LIST_APPEND.
+    if (!pre38ListCompDetected) {
+        // 3.13+ FOR_ITER pushes a sentinel used by END_FOR; keep stack balanced.
+        this.dataStack.push(sentinel);
+    }
 }
 
 function handleForLoopA() {
@@ -143,6 +236,29 @@ function handleGetAiter() {
     // Logic similar to FOR_ITER_A
     let iter = this.dataStack.pop(); // Iterable
 
+    // Async comprehension parameter setup: GET_AITER converts the iterable to an
+    // async iterator before passing it to the genexpr/listcomp function call.
+    // Don't create an AsyncFor block — just forward the iterable.
+    //   3.5-3.6: GET_AITER → LOAD_CONST None → YIELD_FROM → CALL_FUNCTION
+    //   3.7:     GET_AITER → CALL_FUNCTION (no YIELD_FROM needed)
+    const n1 = this.code.Next;
+    if (n1) {
+        const n2 = n1.Next;
+        const n3 = n2?.Next;
+        if (n2 && n3 &&
+            n1.OpCodeID == this.OpCodes.LOAD_CONST_A &&
+            n2.OpCodeID == this.OpCodes.YIELD_FROM &&
+            n3.OpCodeID == this.OpCodes.CALL_FUNCTION_A) {
+            this.dataStack.push(new AST.ASTIteratorValue(iter));
+            this.code.GoNext(2);
+            return;
+        }
+        if (n1.OpCodeID == this.OpCodes.CALL_FUNCTION_A) {
+            this.dataStack.push(new AST.ASTIteratorValue(iter));
+            return;
+        }
+    }
+
     let start = this.code.Current.Offset;
     let end = 0;
     let line = this.code.Current.LineNo;
@@ -284,6 +400,46 @@ function handleEndFor() {
     if (global.g_cliArgs?.debug) {
         console.log(`[END_FOR] at offset ${this.code.Current.Offset}`);
     }
+
+    // Inline comprehension cleanup (3.12+): closing pattern after END_FOR is
+    //   POP_TOP ; SWAP 2 ; STORE_FAST <savedVar>
+    // After LIST_APPEND in comprehension mode, the stack has [..., emptyList, ASTComp].
+    // We rescue ASTComp, drop the empty accumulator, and skip the cleanup ops.
+    if (this._inlineCompSavedVar != null) {
+        const top = this.dataStack.top();
+        if (top instanceof AST.ASTComprehension) {
+            this.dataStack.pop();
+            const below = this.dataStack.top();
+            if ((below instanceof AST.ASTList && (below.values?.length || 0) === 0) ||
+                (below instanceof AST.ASTSet && (below.values?.length || 0) === 0) ||
+                (below instanceof AST.ASTMap && (below.values?.length || 0) === 0)) {
+                this.dataStack.pop();
+            }
+            // Pop the inline-comp for-block and attach its generator to the
+            // comprehension so it renders as `[expr for x in iter]`. Without
+            // this, JUMP_BACKWARD in 3.11+ is a no-op and addGenerator never
+            // fires (control_flow_jumps.js only handles JUMP_ABSOLUTE).
+            const forBlk = this.curBlock;
+            if (forBlk && forBlk.blockType == AST.ASTBlock.BlockType.For && forBlk.comprehension) {
+                top.addGenerator(forBlk);
+                this.blocks.pop();
+                this.curBlock = this.blocks.top();
+            }
+            this.dataStack.push(top);
+        }
+        const saved = this._inlineCompSavedVar;
+        const cand0 = this.code.Next;
+        const cand1 = cand0?.Next;
+        const cand2 = cand1?.Next;
+        if (cand0?.OpCodeID == this.OpCodes.POP_TOP &&
+            cand1?.OpCodeID == this.OpCodes.SWAP_A && cand1.Argument == 2 &&
+            cand2?.OpCodeID == this.OpCodes.STORE_FAST_A && cand2.Name == saved) {
+            this.code.GoNext(3);
+        }
+        this._inlineCompSavedVar = null;
+        return;
+    }
+
     if (this.object.Reader.versionCompare(3, 13) >= 0 && this.dataStack.length > 0) {
         this.dataStack.pop();
     }