depyo 1.0.1 → 1.0.3

package/lib/handlers/exceptions_blocks.js

@@ -132,17 +132,18 @@ function extractWithPatternForFinally() {
 
             if (thirdInstr && thirdInstr.OpCodeID === this.OpCodes.STORE_FAST_A) {
                 // Has "as variable"
-                asVariable = new AST.ASTName(thirdInstr.Name?.toString() || "###FIXME###");
+                if (thirdInstr.Name == null) {
+                    throw new Error(`SETUP_FINALLY (Py2.7 WITH) at offset ${this.code.Current.Offset} (file offset ${this.object.codeOffset + this.code.Current.Offset}): STORE_FAST has null Name`);
+                }
+                asVariable = new AST.ASTName(thirdInstr.Name.toString());
             } else if (thirdInstr && thirdInstr.OpCodeID === this.OpCodes.POP_TOP) {
                 // No "as" clause
                 asVariable = null;
             } else if (thirdInstr && thirdInstr.OpCodeID === this.OpCodes.UNPACK_SEQUENCE_A) {
-                // Tuple unpacking: with expr as (x, y):
-                // Pattern: LOAD_FAST, DELETE_FAST, UNPACK_SEQUENCE n, STORE_FAST..., STORE_FAST...
-                // Use placeholder for tuple unpacking (reconstructing tuple is complex)
-                asVariable = new AST.ASTName("###FIXME###");
-                // Skip LOAD_FAST + DELETE_FAST + UNPACK_SEQUENCE + n STORE_FAST instructions
-                skipCount = 3 + (thirdInstr.Argument || 2);
+                // Tuple unpacking: `with expr as (x, y):` — reconstructing the
+                // tuple of names from UNPACK_SEQUENCE + STORE_FASTs requires
+                // forward instruction collection that this path doesn't yet do.
+                throw new Error(`SETUP_FINALLY (Py2.7 WITH) at offset ${this.code.Current.Offset} (file offset ${this.object.codeOffset + this.code.Current.Offset}): tuple-unpack 'as (...)' clauses not yet supported (UNPACK_SEQUENCE_A at offset ${thirdInstr.Offset})`);
             } else {
                 if (global.g_cliArgs?.debug) {
                     console.log(`WITH pattern (Python 2.7) check failed: third=${thirdInstr?.InstructionName}`);
@@ -228,7 +229,10 @@ function extractWithPatternForFinally() {
             // Check if this is variable assignment (WITH ... as var:)
             if (instr.OpCodeID === this.OpCodes.STORE_FAST_A && i < 5) {
                 // Found variable assignment early in sequence
-                asVariable = new AST.ASTName(instr.Name?.toString() || "###FIXME###");
+                if (instr.Name == null) {
+                    throw new Error(`SETUP_FINALLY (Py3 WITH) at offset ${this.code.Current.Offset} (file offset ${this.object.codeOffset + this.code.Current.Offset}): STORE_FAST at offset ${instr.Offset} has null Name`);
+                }
+                asVariable = new AST.ASTName(instr.Name.toString());
                 skipCount = i + 1;
                 foundBodyStart = true;
                 if (global.g_cliArgs?.debug) {
@@ -323,10 +327,14 @@ function extractContextManager() {
                     instr.OpCodeID === this.OpCodes.LOAD_GLOBAL_A ||
                     instr.OpCodeID === this.OpCodes.LOAD_NAME_A ||
                     instr.OpCodeID === this.OpCodes.LOAD_DEREF_A) {
-                    ctxMgrExpr = new AST.ASTName(instr.Name?.toString() || "###FIXME###");
+                    if (instr.Name == null) {
+                        throw new Error(`extractContextManager: ${instr.InstructionName} at offset ${instr.Offset} has null Name`);
+                    }
+                    ctxMgrExpr = new AST.ASTName(instr.Name.toString());
                 } else {
-                    // For CALL_FUNCTION, LOAD_ATTR, etc., use placeholder
-                    ctxMgrExpr = new AST.ASTName("###FIXME###");
+                    // CALL_FUNCTION/LOAD_ATTR/BINARY_SUBSCR: full expression
+                    // reconstruction needs stack replay (not implemented here).
+                    throw new Error(`extractContextManager: unsupported context manager opcode ${instr.InstructionName} at offset ${instr.Offset} — needs stack replay`);
                 }
                 break;
             }
@@ -353,10 +361,25 @@ function handlePopBlock() {
         return;
     }
 
-    if (this.curBlock.blockType == AST.ASTBlock.BlockType.With) {
+    if (this.curBlock.blockType == AST.ASTBlock.BlockType.With
+            || this.curBlock.blockType == AST.ASTBlock.BlockType.AsyncWith) {
         // This should only be popped by a WITH_CLEANUP
         if (global.g_cliArgs?.debug) {
-            console.log(`POP_BLOCK on WITH block ignored at offset ${this.code.Current.Offset}`);
+            console.log(`POP_BLOCK on ${this.curBlock.type_str.toUpperCase()} block ignored at offset ${this.code.Current.Offset}`);
+        }
+        return;
+    }
+
+    // Py2.x nested genexpr/comprehension: inner loop emits SETUP_LOOP/POP_BLOCK
+    // around FOR_ITER/JUMP_ABSOLUTE. FOR_ITER consumes the SETUP_LOOP's While and
+    // JUMP_ABSOLUTE pops the resulting For, leaving this POP_BLOCK phantom. If it
+    // runs here it pops the enclosing For+comprehension prematurely and orphans
+    // the ASTComprehension sitting on the data stack.
+    if (this.curBlock.blockType == AST.ASTBlock.BlockType.For
+            && this.curBlock.comprehension
+            && this.dataStack.top() instanceof AST.ASTComprehension) {
+        if (global.g_cliArgs?.debug) {
+            console.log(`POP_BLOCK ignored on For+comprehension at offset ${this.code.Current.Offset} (ASTComprehension on stack)`);
         }
         return;
     }
@@ -413,7 +436,11 @@ function handlePopBlock() {
             (tmp.blockType == AST.ASTBlock.BlockType.Try && !this.curBlock.hasExcept)
         ) {
 
-            let final = new AST.ASTBlock(AST.ASTBlock.BlockType.Finally, tmp.start, tmp.end, true);
+            // The Finally body actually starts at container.finally (the SETUP_FINALLY
+            // jump target), not at tmp.start which inherits the popped Else/Try offsets.
+            // End is left as 0 so closeEndedBlocks doesn't pop it before END_FINALLY runs.
+            let finalStart = this.curBlock.finally || tmp.start;
+            let final = new AST.ASTBlock(AST.ASTBlock.BlockType.Finally, finalStart, 0, true);
             this.blocks.push(final);
             this.curBlock = this.blocks.top();
         }
@@ -563,6 +590,36 @@ function handleEndFinally() {
                 if (!this.curBlock.inited) {
                     console.error("Error when decompiling 'async for'.\n");
                 }
+            } else if (asyncForBlock.blockType == AST.ASTBlock.BlockType.AsyncFor && asyncForBlock.inited) {
+                // Initialized AsyncFor: STORE_FAST already set the index.
+                // Extract the loop body from the Container's try block,
+                // close the AsyncFor, and mark remaining handler as unreachable.
+                let tryBlock = container.nodes.find(n => n.blockType == AST.ASTBlock.BlockType.Try);
+                if (tryBlock && !tryBlock.nodes.empty()) {
+                    let store = tryBlock.nodes.find(n => n instanceof AST.ASTStore);
+                    let startIdx = store ? tryBlock.nodes.indexOf(store) + 1 : 0;
+                    for (let i = startIdx; i < tryBlock.nodes.length; i++) {
+                        let node = tryBlock.nodes[i];
+                        if (node && node.constructor.name !== 'ASTReturn' &&
+                            !(node.constructor.name === 'ASTCall' && node.func?.name === 'await')) {
+                            asyncForBlock.nodes.push(node);
+                        }
+                    }
+                    if (asyncForBlock.nodes.length === 0) {
+                        let passNode = new AST.ASTKeyword(AST.ASTKeyword.Word.Pass);
+                        passNode.line = tryBlock.line;
+                        asyncForBlock.nodes.push(passNode);
+                    }
+                }
+                let asyncForEnd = asyncForBlock.end;
+                this.blocks.pop();
+                this.blocks.top().append(asyncForBlock);
+                this.curBlock = this.blocks.top();
+                this.unreachableUntil = asyncForEnd;
+                if (global.g_cliArgs?.debug) {
+                    console.log(`[handleEndFinally-Except] Closed initialized AsyncFor, unreachable until ${asyncForEnd}`);
+                }
+                return;
             } else {
                 this.blocks.push(container);
             }
@@ -782,7 +839,10 @@ function handleRaiseVarargsA() {
     for (let idx = 0; idx < this.code.Current.Argument; idx++) {
         paramList.unshift(this.dataStack.pop());
     }
-    let node = new AST.ASTRaise(paramList);
+    const fromClause =
+        this.code.Current.Argument === 2 &&
+        this.object.Reader.versionCompare(3, 0) >= 0;
+    let node = new AST.ASTRaise(paramList, fromClause);
     node.line = this.code.Current.LineNo;
     this.curBlock.append(node);
 
@@ -919,13 +979,16 @@ function handleCheckEgMatch() {
 }
 
 function handlePrepReraiseStar() {
-    // PREP_RERAISE_STAR separates matched/unmatched parts. Represent as helper call.
-    let value = this.dataStack.pop();
-    let helper = new AST.ASTCall(new AST.ASTName("__prep_reraise_star__"), [value], []);
-    helper.line = this.code.Current.LineNo;
-    this.dataStack.push(helper);
-
-    // Maintain group context for subsequent handlers
+    // CPython 3.11: pops orig + excs list, replaces with None-or-new-EG.
+    // The following POP_JUMP_IF_NOT_NONE/SWAP/POP_EXCEPT/RERAISE sequence is
+    // compiler-generated plumbing for `except*`, not user code. Mirror the
+    // 3.12 CALL_INTRINSIC_2(arg=1) handler: consume stack, suppress the
+    // next conditional, mark exception-group context.
+    this.dataStack.pop();
+    this.dataStack.pop();
+    this.ignoreNextConditional = true;
+    this.cleanupStackDepth = this.dataStack.length + 1;
+    this.dataStack.push(new AST.ASTNone());
     this.inExceptionGroup = true;
 }
 

package/lib/handlers/formatting.js

@@ -1,26 +1,69 @@
 const AST = require('../ast/ast_node');
 
-function handleBuildTemplate() {
-    // Python 3.14 BUILD_TEMPLATE: template objects for f-strings; keep stack as-is (operands already handled by formatting ops).
-    const count = this.code.Current.Argument || 0;
-    const items = [];
-    for (let i = 0; i < count; i++) {
-        items.unshift(this.dataStack.pop());
+// PEP 750 t-strings (Python 3.14+):
+//   strings_tuple ; (value ; str_repr ; [format_spec])+ ; BUILD_INTERPOLATION oparg
+//   ... ; BUILD_TUPLE N ; BUILD_TEMPLATE -> Template
+// BUILD_INTERPOLATION oparg layout:
+//   oparg & 3        = pop count (2 = no format spec, 3 = has format spec)
+//   (oparg >> 2) & 3 = conversion (0=none, 1=!s, 2=!r, 3=!a)
+function handleBuildInterpolationA() {
+    const oparg = this.code.Current.Argument || 0;
+    const popCount = oparg & 3;
+    const convCode = (oparg >> 2) & 3;
+
+    let formatSpec = null;
+    if (popCount === 3) {
+        formatSpec = this.dataStack.pop();
     }
-    // Re-push items as a tuple-like collection to preserve stack shape.
-    const tpl = new AST.ASTTuple(items);
-    tpl.requireParens = false;
-    this.dataStack.push(tpl);
+    this.dataStack.pop(); // discard str representation (used at runtime)
+    const value = this.dataStack.pop();
+
+    const conversion = convCode === 0 ? AST.ASTFormattedValue.ConversionFlag.None
+                     : convCode === 1 ? AST.ASTFormattedValue.ConversionFlag.Str
+                     : convCode === 2 ? AST.ASTFormattedValue.ConversionFlag.Repr
+                     :                  AST.ASTFormattedValue.ConversionFlag.ASCII;
+
+    const node = new AST.ASTFormattedValue(value, conversion, formatSpec);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
 }
 
-function handleBuildInterpolationA() {
-    // Python 3.14 BUILD_INTERPOLATION: build f-string pieces (similar to BUILD_STRING).
-    const count = this.code.Current.Argument || 0;
-    const values = [];
-    for (let i = 0; i < count; i++) {
-        values.push(this.dataStack.pop());
+function handleBuildTemplate() {
+    // Pops (strings_tuple, interpolations_tuple) and produces a Template node.
+    const interpolations = this.dataStack.pop();
+    const strings = this.dataStack.pop();
+
+    let interpVals = [];
+    if (interpolations instanceof AST.ASTTuple) {
+        interpVals = interpolations.values || [];
+    } else if (interpolations?.object?.Value) {
+        interpVals = interpolations.object.Value;
+    }
+
+    // strings is loaded via LOAD_CONST as a Py_Tuple of Py_String objects
+    let stringVals = [];
+    if (strings instanceof AST.ASTTuple) {
+        stringVals = strings.values || [];
+    } else if (strings?.object?.Value) {
+        // Wrap each Py_String in an ASTObject so ASTJoinedStr.codeFragment can render it.
+        stringVals = strings.object.Value.map(pyStr => new AST.ASTObject(pyStr));
     }
-    const joined = new AST.ASTJoinedStr(values);
+
+    // Interleave: str[0], interp[0], str[1], interp[1], ..., str[N]
+    const pieces = [];
+    for (let i = 0; i < stringVals.length; i++) {
+        if (stringVals[i]) {
+            pieces.push(stringVals[i]);
+        }
+        if (i < interpVals.length) {
+            pieces.push(interpVals[i]);
+        }
+    }
+
+    // ASTJoinedStr's codeFragment reverses (BUILD_STRING pops in reverse). Compensate.
+    pieces.reverse();
+    const joined = new AST.ASTJoinedStr(pieces);
+    joined.isTemplateString = true;
     joined.line = this.code.Current.LineNo;
     this.dataStack.push(joined);
 }