depyo 1.0.1 → 1.0.3

package/lib/handlers/function_class_build.js

@@ -60,8 +60,24 @@ function handleMakeFunctionA() {
 }
 
 function handleMakeCellA() {
-    const varNames = this.object?.VarNames?.Value || [];
-    const name = varNames[this.code.Current.Argument]?.toString?.() || `##cell_${this.code.Current.Argument}##`;
+    // In 3.11+ the argument is an index into localsplus ([locals | cells | frees]).
+    // Prefer the already-computed FreeName when available; otherwise fall back to
+    // VarNames + CellVars + FreeVars lookup.
+    const arg = this.code.Current.Argument;
+    let name = this.code.Current.FreeName;
+    if (!name) {
+        const varNames = this.object?.VarNames?.Value || [];
+        const cellVars = this.object?.CellVars?.Value || [];
+        const freeVars = this.object?.FreeVars?.Value || [];
+        if (arg < varNames.length) {
+            name = varNames[arg]?.toString?.();
+        } else if (arg - varNames.length < cellVars.length) {
+            name = cellVars[arg - varNames.length]?.toString?.();
+        } else if (arg - varNames.length - cellVars.length < freeVars.length) {
+            name = freeVars[arg - varNames.length - cellVars.length]?.toString?.();
+        }
+    }
+    if (!name) name = `##cell_${arg}##`;
     this.dataStack.push(new AST.ASTName(name));
 }
 
@@ -76,11 +92,15 @@ function handleSetFunctionAttributeA() {
         const pairs = tupleNode?.values || [];
         for (let i = 0; i + 1 < pairs.length; i += 2) {
             const keyNode = pairs[i];
-            const valNode = pairs[i + 1];
+            let valNode = pairs[i + 1];
             let keyStr = keyNode?.object?.Value || keyNode?.name || keyNode?.codeFragment?.()?.toString?.() || keyNode?.toString?.() || '';
             if (typeof keyStr === 'string') {
                 keyStr = keyStr.replace(/^['"]|['"]$/g, "");
             }
+            // Strip spurious parens around tuple subscripts (e.g. tuple[(T, U)] → tuple[T, U]).
+            if (valNode instanceof AST.ASTSubscr && valNode.key instanceof AST.ASTTuple) {
+                valNode.key.m_requireParens = false;
+            }
             if (keyStr) {
                 annotations[keyStr] = valNode;
             }
@@ -138,87 +158,162 @@ function processMakeFunction() {
 
     let decompiler = new PycDecompiler(func_code.object);
     func_code.object.SourceCode = decompiler.decompile();
+    if (decompiler.errors.length) this.errors.push(...decompiler.errors);
 
-    let annotationMap = null;
-    // Python 3.11+ MAKE_FUNCTION flag bit 0x4 indicates annotations tuple on stack before code object
-    if ((this.object.Reader.versionCompare(3, 11) >= 0) &&
-        (this.code.Current.Argument & 0x04) &&
-        this.dataStack.top() instanceof AST.ASTTuple) {
-        const tupleAnn = this.dataStack.pop();
-        const pairs = tupleAnn.values || [];
-        annotationMap = {};
-        for (let i = 0; i + 1 < pairs.length; i += 2) {
-            const keyNode = pairs[i];
-            const valNode = pairs[i + 1];
-            let keyStr = keyNode?.object?.Value || keyNode?.name || keyNode?.codeFragment?.()?.toString?.() || keyNode?.toString?.() || '';
-            if (typeof keyStr === 'string') {
-                keyStr = keyStr.replace(/^['"]|['"]$/g, "");
+    let defArgs = [], kwDefArgs = [], annotationMap = null;
+
+    const stringifyKey = (keyNode) => {
+        let keyStr = keyNode?.object?.Value ?? keyNode?.name ?? keyNode?.codeFragment?.()?.toString?.() ?? keyNode?.toString?.() ?? '';
+        if (typeof keyStr === 'string') {
+            keyStr = keyStr.replace(/^['"]|['"]$/g, "");
+        }
+        return keyStr;
+    };
+
+    const buildAnnotationMap = (node) => {
+        const map = {};
+        // ASTObject wrapping a Py_Tuple constant — unpack
+        if (node instanceof AST.ASTObject &&
+            (node.object?.ClassName === 'Py_Tuple' || node.object?.ClassName === 'Py_SmallTuple')) {
+            const items = (node.object.Value || []).map(v => new AST.ASTObject(v));
+            for (let i = 0; i + 1 < items.length; i += 2) {
+                const keyStr = stringifyKey(items[i]);
+                if (keyStr) map[keyStr] = items[i + 1];
             }
-            if (keyStr) {
-                annotationMap[keyStr] = valNode;
+            return map;
+        }
+        if (node instanceof AST.ASTTuple) {
+            // Python 3.10+ format: (key1, val1, key2, val2, ...)
+            const pairs = node.values || [];
+            for (let i = 0; i + 1 < pairs.length; i += 2) {
+                const keyStr = stringifyKey(pairs[i]);
+                if (keyStr) map[keyStr] = pairs[i + 1];
+            }
+        } else if (node instanceof AST.ASTConstMap) {
+            // Python 3.6–3.9 (BUILD_CONST_KEY_MAP): keys = ASTObject(tuple of names),
+            // values = array popped from stack in reverse order.
+            const keysObj = node.keys;
+            let flatKeys = [];
+            if (keysObj instanceof AST.ASTObject) {
+                flatKeys = keysObj.object?.Value || [];
+            } else if (Array.isArray(keysObj)) {
+                flatKeys = keysObj;
+            }
+            const valuesArr = Array.isArray(node.values) ? [...node.values].reverse() : [];
+            for (let i = 0; i < Math.min(flatKeys.length, valuesArr.length); i++) {
+                let keyStr = flatKeys[i];
+                if (keyStr && typeof keyStr === 'object') keyStr = keyStr.Value ?? keyStr.toString?.();
+                if (typeof keyStr === 'string') keyStr = keyStr.replace(/^['"]|['"]$/g, "");
+                if (keyStr) map[String(keyStr)] = valuesArr[i];
+            }
+        } else if (node instanceof AST.ASTMap) {
+            // BUILD_MAP form: keys/values added in pairs.
+            const keys = node.keys || [];
+            const values = node.values || [];
+            for (let i = 0; i < Math.min(keys.length, values.length); i++) {
+                const keyStr = stringifyKey(keys[i]);
+                if (keyStr) map[keyStr] = values[i];
             }
         }
-    }
+        return map;
+    };
 
-    let defArgs = [], kwDefArgs = [], annotations = [];
-    const is311Plus = this.object.Reader.versionCompare(3, 11) >= 0;
-    if (is311Plus) {
+    if (this.object.Reader.versionCompare(3, 6) >= 0) {
+        // Python 3.6+ MAKE_FUNCTION uses flag-based encoding.
+        // Stack from top → bottom: [closure(0x08)?, annotations(0x04)?, kwdefaults(0x02)?, defaults(0x01)?]
         const flags = this.code.Current.Argument;
-        // defaults tuple
+        if (flags & 0x08) {
+            this.dataStack.pop(); // closure tuple, captured via cellvars
+        }
+        if (flags & 0x04) {
+            const annNode = this.dataStack.pop();
+            annotationMap = buildAnnotationMap(annNode);
+        }
+        if (flags & 0x02) {
+            const kwDict = this.dataStack.pop();
+            if (kwDict instanceof AST.ASTConstMap || kwDict instanceof AST.ASTMap) {
+                const keys = kwDict.keys || kwDict.m_keys || [];
+                const values = kwDict.values || kwDict.m_values || [];
+                for (let i = 0; i < Math.min(keys.length, values.length); i++) {
+                    kwDefArgs.push({name: keys[i], value: values[i]});
+                }
+            }
+        }
         if (flags & 0x01) {
             const defaults = this.dataStack.pop();
             if (defaults instanceof AST.ASTTuple) {
                 defArgs = defaults.values;
+            } else if (defaults instanceof AST.ASTObject &&
+                       (defaults.object?.ClassName === 'Py_Tuple' || defaults.object?.ClassName === 'Py_SmallTuple')) {
+                defArgs = (defaults.object.Value || []).map(v => new AST.ASTObject(v));
             }
         }
-        // kwdefaults mapping (rare in these fixtures)
-        if (flags & 0x02) {
-            this.dataStack.pop(); // discard kwdefaults for now
-        }
-        // annotations handled earlier (0x04)
-        if (flags & 0x08) {
-            this.dataStack.pop(); // closure tuple
-        }
-    } else {
+    } else if (this.object.Reader.versionCompare(3, 0) >= 0) {
+        // Python 3.0–3.5 MAKE_FUNCTION/MAKE_CLOSURE uses count-based encoding.
+        // arg = (numAnnotations << 16) | (kwDefCount << 8) | defCount
+        // CPython push order (compile.c → ceval.c stack from bottom up):
+        //   [kwdefault_name1, kwdefault_value1, ..., positional_default1, ...,
+        //    annotation_value1, ..., annotation_names_tuple,
+        //    closure_tuple (MAKE_CLOSURE only), code, qualname]
+        // After qualname & code are already popped at top of processMakeFunction,
+        // remaining stack top → bottom:
+        //   [closure_tuple?, annotation_names_tuple?, annotation_values...,
+        //    positional_defaults..., kwdefault pairs (name,value)...]
+        // Pop order: closure → annotations → positional defaults → kwdefaults.
         let defCount = this.code.Current.Argument & 0xFF;
         let kwDefCount = (this.code.Current.Argument >> 8) & 0xFF;
-        let numAnnotations = (this.code.Current.Argument >> 16) & 0xFF;
-        
-        if (this.object.Reader.versionCompare(3, 0) < 0) {
-            for (let idx = 0; idx < defCount; ++idx) {
-                defArgs.unshift(this.dataStack.pop());
-            }
-            
-            if (kwDefCount > 0) {
-                for (let idx = 0; idx < kwDefCount - defCount; ++idx) {
-                    kwDefArgs.unshift(this.dataStack.pop());
-                }
-            }
-        } else {
-            if (numAnnotations > 0) {
-                let tuple = this.dataStack.pop();
-                while (--numAnnotations > 0) {
-                    annotations.push({key: tuple[numAnnotations], value: this.dataStack.pop()})
-                }
-            }
+        let numAnnotations = (this.code.Current.Argument >> 16) & 0x7FFF;
 
-            if (defCount > 0) {
-                while (defCount-- > 0) {
-                    defArgs.unshift(this.dataStack.pop());
-                }
-            }
+        if (this.code.Current.OpCodeID === this.OpCodes.MAKE_CLOSURE_A) {
+            this.dataStack.pop(); // closure tuple — captured via cellvars elsewhere
+        }
 
-            if (kwDefCount > 0) {
-                while (kwDefCount-- > 0) {
-                    let value = this.dataStack.pop();
-                    let name = this.dataStack.pop();
-                    kwDefArgs.unshift({name, value});
-                }
+        if (numAnnotations > 0) {
+            const namesTuple = this.dataStack.pop();
+            // Names tuple is loaded via LOAD_CONST → ASTObject wrapping Py_Tuple,
+            // OR (rare) BUILD_TUPLE → ASTTuple.
+            let rawNames = [];
+            if (namesTuple instanceof AST.ASTObject &&
+                (namesTuple.object?.ClassName === 'Py_Tuple' || namesTuple.object?.ClassName === 'Py_SmallTuple')) {
+                rawNames = namesTuple.object.Value || [];
+            } else if (namesTuple instanceof AST.ASTTuple) {
+                rawNames = namesTuple.values || [];
+            } else if (namesTuple?.object?.Value) {
+                rawNames = namesTuple.object.Value;
+            }
+            const names = rawNames.map(n => {
+                let s = n?.Value ?? n?.object?.Value ?? n?.name ?? n?.toString?.() ?? '';
+                if (typeof s === 'string') s = s.replace(/^['"]|['"]$/g, "");
+                return s;
+            });
+            const valueCount = numAnnotations - 1;
+            const values = [];
+            for (let i = 0; i < valueCount; i++) {
+                values.unshift(this.dataStack.pop());
             }
+            annotationMap = {};
+            for (let i = 0; i < Math.min(names.length, values.length); i++) {
+                if (names[i]) annotationMap[names[i]] = values[i];
+            }
+        }
+        // Positional defaults are popped BEFORE kwdefaults (they were pushed later).
+        for (let idx = 0; idx < defCount; idx++) {
+            defArgs.unshift(this.dataStack.pop());
+        }
+        for (let idx = 0; idx < kwDefCount; idx++) {
+            const value = this.dataStack.pop();
+            const name = this.dataStack.pop();
+            kwDefArgs.unshift({name, value});
+        }
+    } else {
+        // Python 2.x MAKE_FUNCTION: argument is just defCount.
+        const defCount = this.code.Current.Argument & 0xFF;
+        for (let idx = 0; idx < defCount; idx++) {
+            defArgs.unshift(this.dataStack.pop());
         }
     }
 
-    let node = new AST.ASTFunction (func_code, defArgs, kwDefArgs, annotations);
+    let node = new AST.ASTFunction(func_code, defArgs, kwDefArgs);
     if (annotationMap) {
         node.annotations = annotationMap;
     }

package/lib/handlers/generators_async.js

@@ -23,6 +23,73 @@ function handleYieldValue() {
         return;
     }
 
+    // Generator expression: YIELD_VALUE inside a For block tagged as comprehension
+    // produces the genexpr's yielded expression. Mirror LIST_APPEND/SET_ADD pattern:
+    // build an ASTComprehension on the stack so the enclosing JUMP_ABSOLUTE can
+    // attach generators via addGenerator. Skip the trailing POP_TOP that balances
+    // YIELD_VALUE's received-value push in the runtime model.
+    // The yield may fire inside nested If blocks (genexpr with filter condition),
+    // so walk up through If blocks to find the enclosing For+comprehension.
+    let forBlock = null;
+    let ifBlocks = [];
+    if (this.curBlock.blockType == AST.ASTBlock.BlockType.For && this.curBlock.comprehension) {
+        forBlock = this.curBlock;
+    } else {
+        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;
+            }
+        }
+    }
+    if (forBlock) {
+        for (const ifBlk of ifBlocks) {
+            let cond = ifBlk.condition;
+            if (!cond) continue;
+            if (ifBlk.negative) {
+                cond = new AST.ASTUnary(cond, AST.ASTUnary.UnaryOp.Not);
+                cond.line = this.code.Current.LineNo;
+            }
+            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 node = new AST.ASTComprehension(value);
+        node.line = this.code.Current.LineNo;
+        node.kind = AST.ASTComprehension.GENERATOR;
+        this.dataStack.push(node);
+        if (this.code.Next?.OpCodeID == this.OpCodes.POP_TOP) {
+            this.code.GoNext();
+        }
+        return;
+    }
+
+    // Async genexpr inner code: GET_ANEXT iteration uses SETUP_EXCEPT/FINALLY
+    // rather than FOR_ITER, so no For+comp block exists when YIELD_VALUE fires
+    // inside the comprehension body. Save the yielded value so the CALL-site
+    // reconstruction in function_calls.js can use it as the comprehension's
+    // yield expression. We still append ASTReturn below for regular async
+    // generators; the save is harmless because the CALL-site only reads
+    // _asyncCompYieldExpr when reconstructing a recognized comp code object.
+    const objName = this.object?.Name?.toString?.() || '';
+    if (objName.includes('genexpr')) {
+        this.object._asyncCompYieldExpr = value;
+    }
+
     // Python 3.11+: YIELD_VALUE appears in async for loops as implementation detail
     // Skip if we're inside AsyncFor block and value looks like generator machinery
     if (this.object.Reader.versionCompare(3, 11) >= 0) {