depyo 1.2.1 → 1.2.3

package/lib/handlers/collections_update.js

@@ -95,6 +95,14 @@ function processListAppend() {
         let node = new AST.ASTComprehension (value);
         node.line = this.code.Current.LineNo;
         this.dataStack.push(node);
+    } else if (list instanceof AST.ASTList) {
+        // CPython's "big list" path: when a list literal exceeds the
+        // STACK_USE_GUIDELINE and not every element is a compile-time
+        // constant, the compiler emits BUILD_LIST 0 + N×LIST_APPEND
+        // instead of a single BUILD_LIST N. Mutate the list literal in
+        // place; the list reference must remain on top of the data stack
+        // for the next LIST_APPEND (or the final STORE_*) to find it.
+        list.values.push(value);
     } else {
         let node = new AST.ASTSubscr (list, value);
         node.line = this.code.Current.LineNo;

package/lib/handlers/function_calls.js

@@ -26,10 +26,32 @@ const INTRINSIC_2 = Object.freeze({
 });
 
 function handleKwNamesA() {
-    let astNode = new AST.ASTKwNamesMap();
-    let keys = this.code.Current.ConstantObject;
-    for (let idx = keys.length - 1; idx >= 0; idx--) {
-        astNode.add(keys[idx], this.dataStack.pop());
+    // CPython 3.11/3.12: KW_NAMES(consti) stores a reference to co_consts[consti],
+    // which is guaranteed to be a tuple of strings. The following PRECALL/CALL pair
+    // pops that many trailing positional slots and rebinds them as kwargs.
+    //
+    // ConstantObject here is a PythonObject (Py_Tuple or Py_SmallTuple) — NOT a
+    // raw JS array — and each element is a PythonObject (Py_Unicode/Py_String).
+    // The original code did `keys.length - 1` (works via PythonObject.length) but
+    // then `keys[idx]` returned undefined because indexed access does not reach
+    // into `.Value`. The result was an ASTKwNamesMap with `undefined` keys and a
+    // shifted stack that mangled the next CALL into `##ERROR##(func, =val)`.
+    // GitHub depyo.js issue #11.
+    const constObj = this.code.Current.ConstantObject;
+    let keyObjs = [];
+    if (constObj && (constObj.ClassName === 'Py_Tuple' || constObj.ClassName === 'Py_SmallTuple') && Array.isArray(constObj.Value)) {
+        keyObjs = constObj.Value;
+    }
+
+    const toKwName = (v) => {
+        const raw = v?.Value ?? v?.name ?? v;
+        const name = typeof raw === 'string' ? raw : String(raw);
+        return new AST.ASTName(name.replace(/^['"]|['"]$/g, ''));
+    };
+
+    const astNode = new AST.ASTKwNamesMap();
+    for (let idx = keyObjs.length - 1; idx >= 0; idx--) {
+        astNode.add(toKwName(keyObjs[idx]), this.dataStack.pop());
     }
 
     astNode.line = this.code.Current.LineNo;
@@ -177,9 +199,16 @@ function handleInstrumentedCallA() {
         let kwparams_map = this.dataStack.top();
         if (kwparams_map instanceof AST.ASTKwNamesMap) {
             this.dataStack.pop();
+            // CPython 3.11/3.12: KW_NAMES sets the trailing-keyword count for the
+            // next CALL. CALL's oparg is the total positional+keyword count packed
+            // into the low byte (`pparams` here); the high byte (`kwparams`) is
+            // always zero for these versions. Each keyword consumed by KW_NAMES
+            // already popped its value from the stack, so the CALL must pop only
+            // (total - kwcount) positional slots — i.e. decrement `pparams`, not
+            // `kwparams`. depyo.js issue #11.
             for (let kwParam of kwparams_map.values) {
                 kwparamList.unshift(kwParam);
-                kwparams--;
+                pparams--;
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "depyo",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Python bytecode decompiler (Python 1.0–3.15) implemented in Node.js",
   "bin": {
     "depyo": "./depyo.js"