depyo 1.0.2 → 1.0.3

package/lib/ast/ast_node.js

@@ -7,6 +7,19 @@ function indent(level = 1) {
     return Buffer.alloc(level * SPACES_PER_LEVEL, ' ').toString('ascii');
 }
 
+function renderTypeParam(tp) {
+    // PEP 696: a typeparam may be {name, default: ASTNode} instead of a string.
+    if (tp && typeof tp === 'object' && tp.name && tp.default != null && !tp.codeFragment) {
+        const defFrag = tp.default?.codeFragment
+            ? tp.default.codeFragment()
+            : tp.default?.toString?.() ?? String(tp.default);
+        return `${tp.name} = ${defFrag}`;
+    }
+    if (tp?.codeFragment) return tp.codeFragment();
+    if (tp?.toString) return tp.toString();
+    return tp;
+}
+
 class ASTNode {
 
     m_lineNo = -1;
@@ -51,11 +64,7 @@ class ASTNode {
     }
 
     codeFragment() {
-        let result = `#TODO ${this.constructor.name}`;
-        if (result === null || result === undefined) {
-            return `${result}`;
-        }
-        return result;
+        throw new Error(`${this.constructor.name}.codeFragment() not implemented — subclass must override`);
     }
 
     static calculateSpacing(prevNode, node) {
@@ -446,19 +455,29 @@ class ASTObject extends ASTNode {
             }
         }
 
-        let result = this.object.toString();
         if (["Py_String", "Py_Unicode"].includes(this.object.ClassName)) {
+            let raw = this.object.Value;
+            if (raw == null || raw.length === 0) {
+                return '""';
+            }
+            raw = raw.toString();
+            let escaped = raw
+                .replace(/\\/g, '\\\\')
+                .replace(/\n/g, '\\n')
+                .replace(/\r/g, '\\r')
+                .replace(/\t/g, '\\t');
             let quote = '"';
-            if (result.includes('"')) {
-                if (!result.includes("'")) {
+            if (escaped.includes('"')) {
+                if (!escaped.includes("'")) {
                     quote = "'";
                 } else {
-                    quote = '"';
-                    result = result.replace(/"/g, '\\"');
+                    escaped = escaped.replace(/"/g, '\\"');
                 }
             }
-            return quote + result + quote;
+            return quote + escaped + quote;
         }
+
+        let result = this.object.toString();
         if (result === null || result === undefined) {
             return `${result}`;
         }
@@ -498,9 +517,8 @@ class ASTUnary extends ASTNode {
     }
 
     codeFragment() {
-        let result = `${ASTUnary.UnaryOpString[this.op]}${this.operand.codeFragment()}`;
-
-        return result;
+        const operand = this.operand?.codeFragment ? this.operand.codeFragment() : '##ERROR##';
+        return `${ASTUnary.UnaryOpString[this.op]}${operand}`;
     }
 
     toString() {
@@ -568,11 +586,11 @@ class ASTBinary extends ASTNode {
     }
 
     get line() {
-        return this.m_left.line;
+        return this.m_left ? this.m_left.line : this.m_lineNo;
     }
 
     get lastLine() {
-        return this.m_right.line;
+        return this.m_right ? this.m_right.line : this.m_lineNo;
     }
 
     get isInplace() {
@@ -730,6 +748,13 @@ class ASTBinary extends ASTNode {
                 case ASTBinary.BinOp.LeftShift:
                 case ASTBinary.BinOp.RightShift:
                     return 1;
+                // Python `and` binds tighter than `or`; ranking them so that
+                // AND wrapping OR forces parens keeps `(b or c) and d` from
+                // rendering as `b or c and d` (which parses as `b or (c and d)`).
+                case ASTBinary.BinOp.LogicalAnd:
+                    return -1;
+                case ASTBinary.BinOp.LogicalOr:
+                    return -2;
                 default:
                     return 0;
             }
@@ -744,6 +769,13 @@ class ASTBinary extends ASTNode {
                     fragment = `(${fragment})`;
                 }
             }
+            // `0.bit_length()` parses as a bad float literal; wrap integer
+            // literal targets of attribute access in parens.
+            if (this.op === ASTBinary.BinOp.Attr && position === 'left' &&
+                child instanceof ASTObject &&
+                child.object?.ClassName === 'Py_Int') {
+                fragment = `(${fragment})`;
+            }
             return fragment;
         };
 
@@ -944,15 +976,7 @@ class ASTStore extends ASTNode {
                 let isAsync = (codeObject.Flags & ASTFunction.CodeFlags.CO_COROUTINE) ||
                               (codeObject.Flags & ASTFunction.CodeFlags.CO_ASYNC_GENERATOR);
                 result.add(isAsync ? "async ": "");
-                const typeParams = (this.src.typeParams || []).map(tp => {
-                    if (tp?.codeFragment) {
-                        return tp.codeFragment();
-                    }
-                    if (tp?.toString) {
-                        return tp.toString();
-                    }
-                    return tp;
-                });
+                const typeParams = (this.src.typeParams || []).map(tp => renderTypeParam(tp));
                 const typeParamsStr = typeParams.length ? `[${typeParams.join(", ")}]` : "";
                 result.lastLineAppend(`def ${destName}${typeParamsStr}(`);
             }
@@ -1004,29 +1028,58 @@ class ASTStore extends ASTNode {
                             const rawKwName = toVarName(codeObject.VarNames.Value?.[argIndex++]);
                             let argName = rawKwName;
 
-                        // Check if this kwonly arg has a default value
+                        // Python syntax is `name: annotation = default`, so append the
+                        // annotation first and the default afterwards.
+                        const kwAnn = this.src.annotations?.[rawKwName];
+                        if (kwAnn) {
+                            argName = `${argName}: ${kwAnn.codeFragment?.() || kwAnn.toString?.() || '##ERROR##'}`;
+                        }
                         if (default_params && default_params.length > 0) {
                             let defaultIdx = kwIdx - (codeObject.KWOnlyArgCount - default_params.length);
                             if (defaultIdx >= 0 && default_params[defaultIdx]) {
                                 argName += "=" + default_params[defaultIdx].value.codeFragment();
                             }
                         }
-                        const kwAnn = this.src.annotations?.[rawKwName];
-                        if (kwAnn) {
-                            argName = `${argName}: ${kwAnn.codeFragment?.() || kwAnn.toString?.() || '##ERROR##'}`;
-                        }
                         argNames.push(argName);
                     }
                 }
             }
                 if (codeObject.Flags & ASTFunction.CodeFlags.CO_VARARGS) {
-                    argNames.push('*' + toVarName(codeObject.VarNames.Value?.[argIndex++]));
+                    const vaName = toVarName(codeObject.VarNames.Value?.[argIndex++]);
+                    let entry = '*' + vaName;
+                    const vaAnn = this.src.annotations?.[vaName];
+                    if (vaAnn) {
+                        entry += `: ${vaAnn.codeFragment?.() || vaAnn.toString?.() || '##ERROR##'}`;
+                    }
+                    if (codeObject.KWOnlyArgCount) {
+                        // Replace the placeholder "*" we already pushed with the named varargs.
+                        const starIdx = argNames.indexOf('*');
+                        if (starIdx >= 0) {
+                            argNames[starIdx] = entry;
+                        } else {
+                            argNames.push(entry);
+                        }
+                    } else {
+                        argNames.push(entry);
+                    }
                 }
                 if (codeObject.Flags & ASTFunction.CodeFlags.CO_VARKEYWORDS) {
-                    argNames.push('**' + toVarName(codeObject.VarNames.Value?.[argIndex++]));
+                    const vkName = toVarName(codeObject.VarNames.Value?.[argIndex++]);
+                    let entry = '**' + vkName;
+                    const vkAnn = this.src.annotations?.[vkName];
+                    if (vkAnn) {
+                        entry += `: ${vkAnn.codeFragment?.() || vkAnn.toString?.() || '##ERROR##'}`;
+                    }
+                    argNames.push(entry);
                 }
     
-            result.lastLineAppend((argNames.length > 0 ? " " : "") + argNames.join(", "));
+            // Lambda needs a space after the `lambda` keyword before params (shouldTrim would
+            // eat it); `def X(` already has the opening paren and wants no leading space.
+            if (inLambda) {
+                result.lastLineAppend((argNames.length > 0 ? " " : "") + argNames.join(", "), false);
+            } else {
+                result.lastLineAppend(argNames.join(", "));
+            }
             
             if (inLambda) {
                 result.lastLineAppend(": ", false);
@@ -1055,27 +1108,31 @@ class ASTStore extends ASTNode {
             result.decreaseIndent();
 
         } else if (this.src instanceof ASTClass) {
-            if (this.decorators && this.decorators.length > 0) {
-                for (let decorator of this.decorators) {
-                    const decoText = decorator?.codeFragment ? decorator.codeFragment() : decorator;
-                    result.add('@' + decoText);
-                }
+            const allDecorators = [
+                ...(this.src.decorators || []),
+                ...(this.decorators || []),
+            ];
+            for (let decorator of allDecorators) {
+                const decoText = decorator?.codeFragment ? decorator.codeFragment() : decorator;
+                result.add('@' + decoText);
             }
             let classNode = this.src;
-            const typeParams = (classNode.typeParams || []).map(tp => {
-                if (tp?.codeFragment) {
-                    return tp.codeFragment();
-                }
-                if (tp?.toString) {
-                    return tp.toString();
-                }
-                return tp;
-            });
+            const typeParams = (classNode.typeParams || []).map(tp => renderTypeParam(tp));
             const typeParamsStr = typeParams.length ? `[${typeParams.join(", ")}]` : "";
             result.add(`class ${this.dest.codeFragment()}${typeParamsStr}`);
             const bases = classNode?.bases?.values || [];
-            if (bases.length > 0) {
-                result.lastLineAppend(`(${bases.map(node => node?.codeFragment() || "#ERROR##").join(", ")})`, false);
+            const kwargs = classNode?.kwargs || [];
+            const baseStrs = bases.map(node => node?.codeFragment() || "##ERROR##");
+            const kwargStrs = kwargs.map(({key, value}) => {
+                const keyStr = key?.object?.Value?.toString?.() ??
+                               key?.name ??
+                               (typeof key === 'string' ? key : key?.codeFragment?.()?.toString?.());
+                const valStr = value?.codeFragment?.()?.toString?.() ?? "##ERROR##";
+                return `${keyStr}=${valStr}`;
+            });
+            const headerArgs = [...baseStrs, ...kwargStrs];
+            if (headerArgs.length > 0) {
+                result.lastLineAppend(`(${headerArgs.join(", ")})`, false);
             }
             result.lastLineAppend(":");
             let codeObject = classNode.code?.func?.code?.object || classNode.code?.code?.object || {};
@@ -1097,16 +1154,9 @@ class ASTStore extends ASTNode {
             if (global.g_cliArgs?.debug) {
                 console.log(`[ASTStore class render] name=${this.dest?.name}, len=${classBodyNodeList.length}, first=${classBodyNodeList[0]?.constructor?.name}, retVal=${classBodyNodeList[0]?.value?.constructor?.name}, isSyntheticEmptyReturn=${isSyntheticEmptyReturn}, hasContent=${hasContent}`);
             }
-            const hasMetaTypeBase = Array.isArray(classNode?.bases?.values) &&
-                classNode.bases.values.some(b => {
-                    const frag = b?.codeFragment?.();
-                    const str = frag?.toString?.();
-                    return typeof str === 'string' && str.startsWith('type(');
-                });
-
             if (hasContent && !isSyntheticEmptyReturn) {
                 result.add(classBody);
-            } else if (!isSyntheticEmptyReturn && !hasMetaTypeBase) {
+            } else if (!isSyntheticEmptyReturn) {
                 result.add("pass");
             }
             result.decreaseIndent();
@@ -1271,6 +1321,23 @@ class ASTReturn extends ASTNode {
             return result;
         }
 
+        switch (this.rettype) {
+            case ASTReturn.RetType.Yield: {
+                if (!this.value || this.value instanceof ASTNone) {
+                    return new PycResult("(yield)", true);
+                }
+                let yres = new PycResult("(yield ", true);
+                yres.lastLineAppend(this.value.codeFragment());
+                yres.lastLineAppend(")");
+                return yres;
+            }
+            case ASTReturn.RetType.YieldFrom: {
+                let yfres = new PycResult("(yield from ", true);
+                yfres.lastLineAppend(this.value.codeFragment());
+                yfres.lastLineAppend(")");
+                return yfres;
+            }
+        }
         return this.value?.codeFragment() || "";
     }
 
@@ -1398,12 +1465,11 @@ class ASTFunction extends ASTNode {
     m_annotations = {};
     m_typeParams = [];
 
-    constructor(code, defargs = [], kwdefargs = [], annotations = []) {
+    constructor(code, defargs = [], kwdefargs = []) {
         super();
         this.m_code = code;
         this.m_defargs = defargs;
         this.m_kwdefargs = kwdefargs;
-        this.m_decorators = annotations;
     }
 
     get code() {
@@ -1509,6 +1575,8 @@ class ASTClass extends ASTNode {
     m_bases = null;
     m_name = null;
     m_typeParams = [];
+    m_kwargs = [];
+    m_decorators = [];
 
     constructor(code, bases, name) {
         super();
@@ -1517,6 +1585,14 @@ class ASTClass extends ASTNode {
         this.m_name = name;
     }
 
+    add_decorator(decorator) {
+        this.m_decorators.unshift(decorator);
+    }
+
+    get decorators() {
+        return this.m_decorators;
+    }
+
     get code() {
         return this.m_code;
     }
@@ -1529,6 +1605,14 @@ class ASTClass extends ASTNode {
         return this.m_name;
     }
 
+    get kwargs() {
+        return this.m_kwargs || [];
+    }
+
+    set kwargs(value) {
+        this.m_kwargs = value || [];
+    }
+
     get typeParams() {
         return this.m_typeParams || [];
     }
@@ -1631,13 +1715,31 @@ class ASTCall extends ASTNode {
             params.push(this.pparams.map(formatParam).join(', ').trim());
         }
         if (this.kwparams?.length > 0) {
-            params.push(this.kwparams.map(node => `${node?.key?.codeFragment().toString().replaceAll("'",'')} = ${formatParam(node?.value)}`).join(', ').trim());
+            params.push(this.kwparams.map(node => {
+                // Keyword key is stored as a Py_String/Py_Unicode; extract raw identifier
+                // rather than stripping quotes from the rendered literal (which misses
+                // double quotes when the name contains a single quote, etc).
+                let keyStr;
+                const keyObj = node?.key;
+                if (keyObj && keyObj.object && ['Py_String', 'Py_Unicode'].includes(keyObj.object.ClassName)) {
+                    keyStr = keyObj.object.toString();
+                } else {
+                    keyStr = (keyObj?.codeFragment()?.toString() || '').replace(/^['"]|['"]$/g, '');
+                }
+                return `${keyStr}=${formatParam(node?.value)}`;
+            }).join(', ').trim());
         }
         if (this.hasVar) {
             params.push('*' + this.var.codeFragment());
         }
         if (this.hasKw) {
-            params.push('**' + this.kw.codeFragment());
+            if (this.kw instanceof ASTMapUnpack) {
+                for (const item of this.kw.items) {
+                    params.push('**' + (item?.codeFragment?.() ?? '##ERROR##'));
+                }
+            } else {
+                params.push('**' + this.kw.codeFragment());
+            }
         }
         result.lastLineAppend(params.join(', ') + ')');
         return result;
@@ -1858,6 +1960,31 @@ class ASTMap extends ASTNode {
     }
 }
 
+// Py 3.5: BUILD_MAP_UNPACK / BUILD_MAP_UNPACK_WITH_CALL push this. Each item is
+// a mapping expression prefixed with ** at the source level. Items may be
+// literal ASTMap or arbitrary expressions (names, subscripts, calls).
+class ASTMapUnpack extends ASTNode {
+    m_items = [];
+
+    constructor(items) {
+        super();
+        this.m_items = items || [];
+    }
+
+    get items() {
+        return this.m_items;
+    }
+
+    codeFragment() {
+        const parts = this.m_items.map(item => '**' + (item?.codeFragment?.() ?? '##ERROR##'));
+        return '{' + parts.join(', ') + '}';
+    }
+
+    toString() {
+        return `ASTMapUnpack: line=${this.line}, ${this.codeFragment()}`;
+    }
+}
+
 class ASTKwNamesMap extends ASTNode {
     m_values = [];
 
@@ -2105,10 +2232,12 @@ class ASTKeyword extends ASTNode {
 
 class ASTRaise extends ASTNode {
     m_params = [];
+    m_fromClause = false;
 
-    constructor(params) {
+    constructor(params, fromClause = false) {
         super();
         this.m_params = params;
+        this.m_fromClause = fromClause;
     }
 
     get params() {
@@ -2123,6 +2252,9 @@ class ASTRaise extends ASTNode {
         if (!this.params || this.params.length === 0) {
             return 'raise';
         }
+        if (this.m_fromClause && this.params.length === 2) {
+            return 'raise ' + this.params[0].codeFragment() + ' from ' + this.params[1].codeFragment();
+        }
         return 'raise ' + this.params.map(node => node.codeFragment()).join(', ');
     }
 
@@ -2200,7 +2332,8 @@ class ASTBlock extends ASTNode {
         While: 8,
         For: 9,
         With: 10,
-        AsyncFor: 11
+        AsyncFor: 11,
+        AsyncWith: 12
     }
     
     m_blockType = ASTBlock.BlockType.Main;
@@ -2277,7 +2410,7 @@ class ASTBlock extends ASTNode {
     get type_str() {
         return [
             "", "if", "else", "elif", "try", "CONTAINER", "except",
-            "finally", "while", "for", "with", "async for"
+            "finally", "while", "for", "with", "async for", "async with"
         ][this.blockType];
     }
 
@@ -2556,6 +2689,15 @@ class ASTCondBlock extends ASTBlock {
                     node.name == '__exception__') {
                     return false;
                 }
+                // Inside an except body, an empty else block is a control-flow
+                // artifact (JUMP_ABSOLUTE leaving the handler with no body);
+                // keeping it leaves the handler visually empty without `pass`.
+                if (this.blockType == ASTBlock.BlockType.Except &&
+                    node instanceof ASTBlock &&
+                    node.blockType === ASTBlock.BlockType.Else &&
+                    node.empty()) {
+                    return false;
+                }
                 return node && !node.skip && node.codeFragment;
             });
 
@@ -2654,7 +2796,12 @@ class ASTIterBlock extends ASTBlock {
         result.lastLineAppend(this.iter?.codeFragment() || "##ERROR##");
         result.lastLineAppend(":");
         result.increaseIndent();
-        this.nodes.map(node => node && result.add(node.codeFragment()));
+        const body = this.nodes.filter(Boolean);
+        if (body.length === 0) {
+            result.add("pass");
+        } else {
+            body.forEach(node => result.add(node.codeFragment()));
+        }
         result.decreaseIndent();
 
         return result;
@@ -2753,9 +2900,70 @@ class ASTWithBlock extends ASTBlock {
         
         result.lastLineAppend(":");
         result.increaseIndent();
-        this.nodes.filter(Boolean).forEach(node => result.add(node.codeFragment()));
+        const body = this.nodes.filter(Boolean);
+        if (body.length === 0) {
+            result.add("pass");
+        } else {
+            body.forEach(node => result.add(node.codeFragment()));
+        }
         result.decreaseIndent();
-        
+
+        return result;
+    }
+
+    toString() {
+        return `${this.type_str} block: {${this.start} - ${this.end}}`;
+    }
+}
+
+class ASTAsyncWithBlock extends ASTBlock {
+
+    m_expr = null;
+    m_var = null;
+
+    constructor(start = 0, end = 0) {
+        super(ASTBlock.BlockType.AsyncWith, start, end);
+    }
+
+    get expr() {
+        return this.m_expr;
+    }
+
+    set expr(value) {
+        this.m_expr = value;
+    }
+
+    get var() {
+        return this.m_var;
+    }
+
+    set var(value) {
+        this.m_var = value;
+    }
+
+    codeFragment() {
+        let result = new PycResult();
+        result.doNotIndent = true;
+
+        result.lastLineAppend("async with ", false);
+        const exprCode = this.expr?.codeFragment ? this.expr.codeFragment() : "None";
+        result.lastLineAppend(exprCode);
+
+        if (this.var) {
+            result.lastLineAppend(" as ", false);
+            result.lastLineAppend(this.var.codeFragment());
+        }
+
+        result.lastLineAppend(":");
+        result.increaseIndent();
+        const body = this.nodes.filter(Boolean);
+        if (body.length === 0) {
+            result.add("pass");
+        } else {
+            body.forEach(node => result.add(node.codeFragment()));
+        }
+        result.decreaseIndent();
+
         return result;
     }
 
@@ -2769,6 +2977,7 @@ class ASTComprehension extends ASTNode {
     static LIST = 0;
     static SET = 1;
     static DICT = 2;
+    static GENERATOR = 3;
 
     m_kind = ASTComprehension.LIST;
     m_key = null;
@@ -2820,6 +3029,9 @@ class ASTComprehension extends ASTNode {
         if ([ASTComprehension.SET, ASTComprehension.DICT].includes(this.kind)) {
             openingBracket = '{';
             closingBracket = '}';
+        } else if (this.kind == ASTComprehension.GENERATOR) {
+            openingBracket = '(';
+            closingBracket = ')';
         }
 
         if (!this.result) {
@@ -2829,7 +3041,8 @@ class ASTComprehension extends ASTNode {
         let result = `${openingBracket}${this.kind == ASTComprehension.DICT ? (this.key?.codeFragment() || "##ERROR##") + ": " : ""}${this.result.codeFragment?.() || "##ERROR##"}`;
 
         result += this.generators.map(gen => {
-            let genString = ` for ${gen.index?.codeFragment?.() || "##ERROR##"} in ${gen.iter?.codeFragment?.() || "##ERROR##"}`;
+            let asyncPrefix = gen.blockType == ASTBlock.BlockType.AsyncFor ? 'async ' : '';
+            let genString = ` ${asyncPrefix}for ${gen.index?.codeFragment?.() || "##ERROR##"} in ${gen.iter?.codeFragment?.() || "##ERROR##"}`;
 
             if (gen.condition) {
                 genString += ` if ${gen.condition.codeFragment?.() || "##ERROR##"}`;
@@ -2984,8 +3197,8 @@ class ASTJoinedStr extends ASTNode {
         return this.values[this.values.length - 1]?.lastLine;
     }
     codeFragment() {
-        // f-string format: f"literal {expr} literal"
-        let result = 'f"';
+        // PEP 750 t-strings use t"..." prefix; otherwise f-string.
+        let result = (this.isTemplateString ? 't"' : 'f"');
 
         // Values are in reverse order (BUILD_STRING pops from stack)
         // So we need to reverse them
@@ -2994,6 +3207,12 @@ class ASTJoinedStr extends ASTNode {
         for (let i = 0; i < values.length; i++) {
             let value = values[i];
 
+            // Stack underflow during BUILD_STRING leaves undefined slots; skip them
+            // rather than crashing post-decompile passes that re-render this node.
+            if (value == null) {
+                continue;
+            }
+
             if (value instanceof ASTFormattedValue) {
                 // Check for f-string = debugging pattern (Python 3.8+)
                 // Pattern: literal ending with "varname=" followed by {varname!r}
@@ -3379,7 +3598,7 @@ class ASTPattern extends ASTNode {
                 return '##ERROR##';
 
             default:
-                return '#TODO pattern';
+                throw new Error(`ASTPattern.codeFragment(): unsupported pattern type '${this.m_type}'`);
         }
     }
 
@@ -3412,6 +3631,7 @@ module.exports = {
     ASTList,
     ASTSet,
     ASTMap,
+    ASTMapUnpack,
     ASTKwNamesMap,
     ASTConstMap,
     ASTSubscr,
@@ -3425,6 +3645,7 @@ module.exports = {
     ASTIterBlock,
     ASTContainerBlock,
     ASTWithBlock,
+    ASTAsyncWithBlock,
     ASTComprehension,
     ASTLoadBuildClass,
     ASTAwaitable,

package/lib/bytecode/python_3_0.js

@@ -47,7 +47,7 @@ const opcodes = [
     [68, new OpCode(OpCodes.GET_ITER, "GET_ITER")],
     [69, new OpCode(OpCodes.STORE_LOCALS, "STORE_LOCALS")],
     [70, new OpCode(OpCodes.PRINT_EXPR, "PRINT_EXPR")],
-    [71, new OpCode(OpCodes.PRINT_ITEM, "PRINT_ITEM")],
+    [71, new OpCode(OpCodes.LOAD_BUILD_CLASS, "LOAD_BUILD_CLASS")],
 
     [75, new OpCode(OpCodes.INPLACE_LSHIFT, "INPLACE_LSHIFT")],
     [76, new OpCode(OpCodes.INPLACE_RSHIFT, "INPLACE_RSHIFT")],

package/lib/bytecode/python_3_12.js

@@ -134,7 +134,7 @@ const opcodes = [
     [173, new OpCode(OpCodes.CALL_INTRINSIC_1, "CALL_INTRINSIC_1", {HasArgument: true, HasIntrisic1: true})],
     [174, new OpCode(OpCodes.CALL_INTRINSIC_2, "CALL_INTRINSIC_2", {HasArgument: true, HasIntrisic2: true})],
     [175, new OpCode(OpCodes.LOAD_FROM_DICT_OR_GLOBALS_A, "LOAD_FROM_DICT_OR_GLOBALS", {HasArgument: true, HasName: true})],
-    [176, new OpCode(OpCodes.LOAD_FROM_DICT_OR_DEREF_A, "LOAD_FROM_DICT_OR_DEREF", {HasArgument: true, HasName: true, HasLocal: true})],
+    [176, new OpCode(OpCodes.LOAD_FROM_DICT_OR_DEREF_A, "LOAD_FROM_DICT_OR_DEREF", {HasArgument: true, HasFree: true})],
 
     [237, new OpCode(OpCodes.INSTRUMENTED_LOAD_SUPER_ATTR_A, "INSTRUMENTED_LOAD_SUPER_ATTR", {HasArgument: true, HasName: true, HasFlags: true})],
     [238, new OpCode(OpCodes.INSTRUMENTED_POP_JUMP_IF_NONE_A, "INSTRUMENTED_POP_JUMP_IF_NONE", {HasArgument: true, HasJumpRelative: true})],