depyo 1.0.2 → 1.1.0

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) {
@@ -249,7 +258,19 @@ class ASTNodeList extends ASTNode {
                     }
                 }
     
-                if (prevNode && spacing == 0 && sourceFragment.length == 1) {
+                // Only join with `; ` between two simple (non-compound) statements
+                // that also happen to be on the same source line. A compound block
+                // (if/while/for/try/function/class) must never be semicolon-joined
+                // to a following sibling — doing so swallows the sibling into the
+                // block's body and breaks structure.
+                const prevIsCompound = prevNode instanceof ASTBlock ||
+                                       prevNode instanceof ASTFunction ||
+                                       prevNode instanceof ASTClass;
+                const nodeIsCompound = node instanceof ASTBlock ||
+                                       node instanceof ASTFunction ||
+                                       node instanceof ASTClass;
+                if (prevNode && spacing == 0 && sourceFragment.length == 1 &&
+                    !prevIsCompound && !nodeIsCompound) {
                     result.lastLineAppend((prevNode ? "; " : "") + sourceFragment.toString(), false);
                 } else {
                     const blankCount = rawSpacing ? Math.max(0, spacing - 1) : (spacing > 1 ? 1 : 0);
@@ -446,19 +467,33 @@ 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')
+                // Any remaining C0/DEL byte must be hex-escaped; leaving a raw
+                // NUL or BEL in the source makes the output unparseable.
+                .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, c =>
+                    '\\x' + c.charCodeAt(0).toString(16).padStart(2, '0'));
             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 +533,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 +602,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 +764,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 +785,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 +992,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 +1044,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);
@@ -1050,32 +1119,42 @@ class ASTStore extends ASTNode {
             if (inLambda) {
                 result.lastLineAppend(methodBody);
             } else {
-                result.add(methodBody);
+                const bodyHasContent = methodBody && methodBody.toString().trim().length;
+                const hasGlobals = codeObject.Globals && codeObject.Globals.size > 0;
+                if (bodyHasContent) {
+                    result.add(methodBody);
+                } else if (!hasGlobals) {
+                    result.add("pass");
+                }
             }
             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 +1176,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 +1343,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 +1487,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 +1597,8 @@ class ASTClass extends ASTNode {
     m_bases = null;
     m_name = null;
     m_typeParams = [];
+    m_kwargs = [];
+    m_decorators = [];
 
     constructor(code, bases, name) {
         super();
@@ -1517,6 +1607,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 +1627,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 +1737,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 +1982,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 +2254,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 +2274,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 +2354,8 @@ class ASTBlock extends ASTNode {
         While: 8,
         For: 9,
         With: 10,
-        AsyncFor: 11
+        AsyncFor: 11,
+        AsyncWith: 12
     }
     
     m_blockType = ASTBlock.BlockType.Main;
@@ -2277,7 +2432,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];
     }
 
@@ -2406,19 +2561,33 @@ class ASTBlock extends ASTNode {
                     result.add("pass");
                 }
             } else {
+                // Emit body nodes first, then trailing dedented handlers. If
+                // every body node was `skip`-ed (e.g. Try body whose sole
+                // child was consumed by ternary collapse), the block would
+                // print `try:` with no body — inject a `pass` placeholder so
+                // the resulting source stays parseable.
+                let emittedBodyNode = false;
+                const handlerTail = [];
                 renderNodes.map(node => {
                     if (!node || node.skip) {
                         return;
                     }
                     const isHandler = node.blockType == ASTBlock.BlockType.Except || node.blockType == ASTBlock.BlockType.Finally;
                     if (isHandler) {
-                        result.decreaseIndent();
-                        result.add(node.codeFragment());
-                        result.increaseIndent();
+                        handlerTail.push(node);
                     } else {
                         result.add(node.codeFragment());
+                        emittedBodyNode = true;
                     }
                 });
+                if (!emittedBodyNode) {
+                    result.add("pass");
+                }
+                for (const h of handlerTail) {
+                    result.decreaseIndent();
+                    result.add(h.codeFragment());
+                    result.increaseIndent();
+                }
             }
         } else {
             result.add("pass");
@@ -2556,6 +2725,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 +2832,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 +2936,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 +3013,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 +3065,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 +3077,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##"}`;
@@ -2924,12 +3173,27 @@ class ASTFormattedValue extends ASTNode {
         return this.m_format_spec;
     }
     
-    codeFragment() {
+    codeFragment(outerQuote = null) {
         // Format: {value} or {value!r} or {value:.2f}
+        // `outerQuote` is set only when this FormattedValue is being rendered
+        // inside an enclosing f-string; nested strings must then use the
+        // opposite delimiter so the outer string does not close prematurely.
+        const innerQuote = outerQuote === '"' ? "'" :
+                           outerQuote === "'" ? '"' : '"';
         let result = "{";
 
         if (this.m_val) {
-            result += this.m_val.codeFragment();
+            if (this.m_val instanceof ASTJoinedStr) {
+                // Only force a flipped quote when we actually have an outer
+                // f-string; otherwise let the nested string keep its default.
+                if (outerQuote) {
+                    result += this.m_val.codeFragment(innerQuote);
+                } else {
+                    result += this.m_val.codeFragment();
+                }
+            } else {
+                result += this.m_val.codeFragment();
+            }
         }
 
         // Add conversion flag (!s, !r, !a)
@@ -2950,7 +3214,10 @@ class ASTFormattedValue extends ASTNode {
             result += ":";
             // Format spec can be ASTJoinedStr (nested f-string) or string constant
             if (this.m_format_spec instanceof ASTJoinedStr) {
-                result += this.m_format_spec.codeFragment();
+                // Format-spec content is already inside the outer f-string's
+                // braces, so its literal parts must not use the outer quote.
+                const specQuote = outerQuote ? innerQuote : '"';
+                result += this.m_format_spec.codeFragment(specQuote, true);
             } else if (this.m_format_spec instanceof ASTObject) {
                 // String constant like ".2f"
                 result += this.m_format_spec.object.Value;
@@ -2983,9 +3250,14 @@ class ASTJoinedStr extends ASTNode {
     get lastLine() {
         return this.values[this.values.length - 1]?.lastLine;
     }
-    codeFragment() {
-        // f-string format: f"literal {expr} literal"
-        let result = 'f"';
+    codeFragment(quoteChar = '"', bareInnerForFormatSpec = false) {
+        // PEP 750 t-strings use t"..." prefix; otherwise f-string.
+        // `quoteChar` lets nested f-strings pick the opposite delimiter so
+        // they don't collide with the enclosing string. `bareInnerForFormatSpec`
+        // skips the f"..." wrapper entirely (used when this ASTJoinedStr is a
+        // format spec nested inside {...}).
+        const prefix = this.isTemplateString ? 't' : 'f';
+        let result = bareInnerForFormatSpec ? "" : `${prefix}${quoteChar}`;
 
         // Values are in reverse order (BUILD_STRING pops from stack)
         // So we need to reverse them
@@ -2994,6 +3266,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}
@@ -3013,8 +3291,10 @@ class ASTJoinedStr extends ASTNode {
                         let prefix = prevStr.substring(0, prevStr.length - match[0].length);
 
                         // Remove the previously added literal and replace with prefix + {var=}
+                        let quoteEsc = quoteChar === '"' ? /"/g : /'/g;
+                        let quoteReplace = quoteChar === '"' ? '\\"' : "\\'";
                         let beforeLiteral = result.lastIndexOf(prevStr.replace(/\\/g, '\\\\')
-                            .replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\t/g, '\\t'));
+                            .replace(quoteEsc, quoteReplace).replace(/\n/g, '\\n').replace(/\t/g, '\\t'));
 
                         if (beforeLiteral !== -1) {
                             result = result.substring(0, beforeLiteral);
@@ -3023,7 +3303,7 @@ class ASTJoinedStr extends ASTNode {
                         // Add prefix (escaped) if present
                         if (prefix) {
                             let escapedPrefix = prefix.replace(/\\/g, '\\\\');
-                            escapedPrefix = escapedPrefix.replace(/"/g, '\\"');
+                            escapedPrefix = escapedPrefix.replace(quoteEsc, quoteReplace);
                             escapedPrefix = escapedPrefix.replace(/\n/g, '\\n');
                             escapedPrefix = escapedPrefix.replace(/\t/g, '\\t');
                             result += escapedPrefix;
@@ -3035,16 +3315,25 @@ class ASTJoinedStr extends ASTNode {
                     }
                 }
 
-                // {expression} part
-                result += value.codeFragment();
-            } else if (value instanceof ASTObject && value.object?.ClassName === 'Py_String') {
+                // {expression} part - pass our own quote char so nested
+                // f-strings / strings inside pick a compatible delimiter.
+                result += value.codeFragment(quoteChar);
+                // result above calls ASTFormattedValue.codeFragment(outerQuote).
+            } else if (value instanceof ASTObject && ['Py_String', 'Py_Unicode'].includes(value.object?.ClassName)) {
                 // Literal string part - need to escape special chars
                 let str = value.object.Value;
-                // Escape backslashes and quotes
+                // Escape backslashes and the current quote char
                 str = str.replace(/\\/g, '\\\\');
-                str = str.replace(/"/g, '\\"');
+                if (quoteChar === '"') {
+                    str = str.replace(/"/g, '\\"');
+                } else {
+                    str = str.replace(/'/g, "\\'");
+                }
                 str = str.replace(/\n/g, '\\n');
+                str = str.replace(/\r/g, '\\r');
                 str = str.replace(/\t/g, '\\t');
+                str = str.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, c =>
+                    '\\x' + c.charCodeAt(0).toString(16).padStart(2, '0'));
                 result += str;
             } else {
                 // Fallback for unexpected types
@@ -3052,7 +3341,9 @@ class ASTJoinedStr extends ASTNode {
             }
         }
 
-        result += '"';
+        if (!bareInnerForFormatSpec) {
+            result += quoteChar;
+        }
         return result;
     }
 
@@ -3379,7 +3670,7 @@ class ASTPattern extends ASTNode {
                 return '##ERROR##';
 
             default:
-                return '#TODO pattern';
+                throw new Error(`ASTPattern.codeFragment(): unsupported pattern type '${this.m_type}'`);
         }
     }
 
@@ -3412,6 +3703,7 @@ module.exports = {
     ASTList,
     ASTSet,
     ASTMap,
+    ASTMapUnpack,
     ASTKwNamesMap,
     ASTConstMap,
     ASTSubscr,
@@ -3425,6 +3717,7 @@ module.exports = {
     ASTIterBlock,
     ASTContainerBlock,
     ASTWithBlock,
+    ASTAsyncWithBlock,
     ASTComprehension,
     ASTLoadBuildClass,
     ASTAwaitable,