@kernlang/python 3.5.6-canary.196.1.72010f21 → 3.5.6

package/dist/fastapi-response.js

@@ -6,7 +6,8 @@
  * extractExprCode       — extract expression code from IR prop
  * addRespondImports     — add necessary imports for respond node
  */
-import { getProps } from '@kernlang/core';
+import { getProps, lowerJsClosureBodyToPython } from '@kernlang/core';
+import { KERN_I32_HELPER_PY, KERN_JS_HELPER_PY, KERN_TMOD_HELPER_PY } from './codegen-body-python.js';
 import { escapePyStr, quoteObjectKeysOutsideStrings } from './fastapi-utils.js';
 import { toSnakeCase } from './type-map.js';
 export function generateRespondFastAPI(respondNode, indent) {
@@ -111,7 +112,7 @@ function lowerDictMemberAccess(text, varName) {
                     // (codex review of ab192611). A lone `x.method()` is unchanged.
                     const dataFields = fields.slice(0, -1);
                     const methodField = fields[fields.length - 1];
-                    out += varName + dataFields.map((field) => `[${JSON.stringify(field)}]`).join('') + `.${methodField}`;
+                    out += `${varName + dataFields.map((field) => `[${JSON.stringify(field)}]`).join('')}.${methodField}`;
                 }
                 else {
                     out += varName + fields.map((field) => `[${JSON.stringify(field)}]`).join('');
@@ -125,6 +126,53 @@ function lowerDictMemberAccess(text, varName) {
     }
     return out;
 }
+// A statement body that is EXACTLY `{ return E; }` is semantically identical to the
+// expression body `E`, so unwrap it to reuse the expression-bodied lowering (slice 1 of
+// native closures, #5). Richer statement bodies (locals, control flow, side effects
+// before the return) need full closure lowering (hoisted nested defs) and are NOT handled
+// here — they stay untouched (still unsupported) rather than mis-lowered. The scan is
+// string/bracket-aware so `{ return f({a:1}); }` unwraps but `{ return a; more(); }` does not.
+function unwrapSingleReturnBlock(body) {
+    const t = body.trim();
+    if (t.length < 2 || t[0] !== '{' || t[t.length - 1] !== '}')
+        return body;
+    const topLevelBreaks = (s, breakOnSemicolon) => {
+        let depth = 0;
+        let inStr = null;
+        for (let i = 0; i < s.length; i++) {
+            const c = s[i];
+            if (inStr) {
+                if (c === inStr && s[i - 1] !== '\\')
+                    inStr = null;
+                continue;
+            }
+            if (c === '"' || c === "'" || c === '`')
+                inStr = c;
+            else if (c === '{' || c === '(' || c === '[')
+                depth++;
+            else if (c === '}' || c === ')' || c === ']') {
+                depth--;
+                // the opening brace must match the FINAL char, else `{..}{..}` etc.
+                if (!breakOnSemicolon && depth === 0 && i !== s.length - 1)
+                    return true;
+            }
+            else if (breakOnSemicolon && c === ';' && depth === 0)
+                return true;
+        }
+        return false;
+    };
+    if (topLevelBreaks(t, false))
+        return body; // outer braces don't span the whole body
+    let inner = t.slice(1, -1).trim();
+    if (!/^return\b/.test(inner))
+        return body;
+    inner = inner.slice(6).trim();
+    if (inner.endsWith(';'))
+        inner = inner.slice(0, -1).trim();
+    if (!inner || topLevelBreaks(inner, true))
+        return body; // empty or multi-statement
+    return inner;
+}
 // Parse an arrow callback's argument text into `{ params, body }`, or null when
 // it isn't a single arrow function (e.g. `.map(fn)` with a bare reference, which
 // is left unchanged). Handles `(p) => body`, `p => body`, and `(p, i) => body`.
@@ -140,12 +188,12 @@ function parseArrowCallback(inner) {
         const params = splitTopLevelArgs(trimmed.slice(1, close))
             .map((s) => s.trim())
             .filter(Boolean);
-        return { params, body: after.slice(2).trim() };
+        return { params, body: unwrapSingleReturnBlock(after.slice(2).trim()) };
     }
     const m = trimmed.match(/^([A-Za-z_$][\w$]*)\s*=>\s*([\s\S]+)$/);
     if (!m)
         return null;
-    return { params: [m[1]], body: m[2].trim() };
+    return { params: [m[1]], body: unwrapSingleReturnBlock(m[2].trim()) };
 }
 // Lower JS arrow-callback array methods to Python comprehensions:
 //   arr.filter((x) => pred)      -> [x for x in arr if pred]
@@ -170,6 +218,7 @@ const PORTABLE_ARRAY_METHODS = new Set([
     'sort',
     'flat',
     'at',
+    'push',
     'reverse',
     'concat',
     'fill',
@@ -177,7 +226,31 @@ const PORTABLE_ARRAY_METHODS = new Set([
     'reduceRight',
 ]);
 const LAMBDA_COLON_PLACEHOLDER = '__KERN_LAMBDA_COLON__';
-function lowerJsArrayMethods(expr, imports) {
+function lowerArrowBlockClosure(arrow, ctx) {
+    if (!arrow.body.trim().startsWith('{'))
+        return null;
+    const seq = ctx.closureSeq ?? { n: 0 };
+    const name = `__kern_closure_${seq.n++}`;
+    if (!ctx.closureSeq)
+        ctx.closureSeq = seq;
+    const result = lowerJsClosureBodyToPython(arrow.body, {
+        lowerExpression: (raw) => rewriteFastAPIExpr(lowerDictMemberAccess(raw, arrow.params[0]), ctx.pathParams, ctx.bodyFields, ctx.authUser, ctx.imports, undefined, ctx.closureSeq),
+        lowerCondition: (raw) => `js_truthy(${rewriteFastAPIExpr(lowerDictMemberAccess(raw, arrow.params[0]), ctx.pathParams, ctx.bodyFields, ctx.authUser, ctx.imports, undefined, ctx.closureSeq)})`,
+    });
+    if (!result.ok)
+        return null;
+    ctx.imports?.add(KERN_JS_HELPER_PY);
+    const params = arrow.params.join(', ');
+    const def = [`def ${name}(${params}):`, ...(result.lines.length > 0 ? result.lines : ['    pass'])].join('\n');
+    if (ctx.hoistedDefs) {
+        ctx.hoistedDefs.push(def);
+    }
+    else {
+        ctx.imports?.add(def);
+    }
+    return `${name}(${arrow.params.join(', ')})`;
+}
+function lowerJsArrayMethods(expr, ctx) {
     let out = '';
     let i = 0;
     let quote = null;
@@ -216,7 +289,8 @@ function lowerJsArrayMethods(expr, imports) {
                     const idxVar = arrow.params[1];
                     // Recurse for nested array methods in the body; subscript the element
                     // var's member access. The index var (if any) stays a bare int.
-                    const body = lowerJsArrayMethods(lowerDictMemberAccess(arrow.body, elemVar), imports);
+                    const blockClosure = lowerArrowBlockClosure(arrow, ctx);
+                    const body = blockClosure ?? lowerJsArrayMethods(lowerDictMemberAccess(arrow.body, elemVar), ctx);
                     // A second callback param is the element index — bind it via
                     // enumerate() for every method, not just map, so a predicate that
                     // references the index (`(x, i) => i > 0`) doesn't emit an unbound
@@ -270,7 +344,7 @@ function lowerJsArrayMethods(expr, imports) {
             if (closeIdx !== -1 && recvStart !== -1) {
                 const receiver = out.slice(recvStart);
                 const pre = out.slice(0, recvStart);
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx)).map((a) => lowerJsArrayMethods(a.trim(), imports));
+                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx)).map((a) => lowerJsArrayMethods(a.trim(), ctx));
                 let lowered = null;
                 if (method === 'includes') {
                     const needle = args[0] ?? '';
@@ -286,6 +360,25 @@ function lowerJsArrayMethods(expr, imports) {
                         lowered = `(next((__i for __i, __v in enumerate(${receiver}) if __v == ${needle}), -1))`;
                     }
                 }
+                else if (method === 'push') {
+                    // JS Array.push mutates AND returns the new length. Python list.append
+                    // returns None, so emit `(recv.append(x) or len(recv))` for exact parity
+                    // (mutate + length). Single-arg only; varargs push left unsupported.
+                    if (args.length === 1)
+                        lowered = `(${receiver}.append(${args[0]}) or len(${receiver}))`;
+                }
+                else if (method === 'reverse') {
+                    // JS Array.reverse mutates AND returns the (same, reversed) array; Python
+                    // list.reverse returns None -> `(recv.reverse() or recv)` mutates + returns it.
+                    lowered = `(${receiver}.reverse() or ${receiver})`;
+                }
+                else if (method === 'concat') {
+                    // JS Array.concat returns a NEW array; an array arg is spread, a scalar arg
+                    // is appended. Mirror with `recv + (x if isinstance(x, list) else [x])`.
+                    // Single-arg only; varargs concat left unsupported.
+                    if (args.length === 1)
+                        lowered = `(${receiver} + (${args[0]} if isinstance(${args[0]}, list) else [${args[0]}]))`;
+                }
                 else if (method === 'join') {
                     const sep = args[0] ?? '","';
                     lowered = `${sep}.join(str(__v) for __v in ${receiver})`;
@@ -309,7 +402,8 @@ function lowerJsArrayMethods(expr, imports) {
                         const idxVar = arrow.params[1];
                         // Only the element var is dict-subscripted; the index var stays a
                         // bare int and must be bound via enumerate() when present.
-                        const pred = lowerJsArrayMethods(lowerDictMemberAccess(arrow.body, elemVar), imports);
+                        const blockClosure = lowerArrowBlockClosure(arrow, ctx);
+                        const pred = blockClosure ?? lowerJsArrayMethods(lowerDictMemberAccess(arrow.body, elemVar), ctx);
                         const loopTarget = idxVar ? `${idxVar}, ${elemVar}` : elemVar;
                         const source = idxVar ? `enumerate(${receiver})` : receiver;
                         lowered =
@@ -326,10 +420,10 @@ function lowerJsArrayMethods(expr, imports) {
                         const elemVar = arrow.params[1];
                         let body = lowerDictMemberAccess(arrow.body, accVar);
                         body = lowerDictMemberAccess(body, elemVar);
-                        const loweredBody = lowerJsArrayMethods(body, imports);
-                        imports?.add('import functools');
+                        const loweredBody = lowerJsArrayMethods(body, ctx);
+                        ctx.imports?.add('import functools');
                         if (rawArgs.length >= 2) {
-                            const seed = lowerJsArrayMethods(rawArgs[1].trim(), imports);
+                            const seed = lowerJsArrayMethods(rawArgs[1].trim(), ctx);
                             lowered = `functools.reduce(lambda ${accVar}, ${elemVar}${LAMBDA_COLON_PLACEHOLDER} ${loweredBody}, ${receiver}, ${seed})`;
                         }
                         else {
@@ -346,10 +440,10 @@ function lowerJsArrayMethods(expr, imports) {
                         const elemVar = arrow.params[1];
                         let body = lowerDictMemberAccess(arrow.body, accVar);
                         body = lowerDictMemberAccess(body, elemVar);
-                        const loweredBody = lowerJsArrayMethods(body, imports);
-                        imports?.add('import functools');
+                        const loweredBody = lowerJsArrayMethods(body, ctx);
+                        ctx.imports?.add('import functools');
                         if (rawArgs.length >= 2) {
-                            const seed = lowerJsArrayMethods(rawArgs[1].trim(), imports);
+                            const seed = lowerJsArrayMethods(rawArgs[1].trim(), ctx);
                             lowered = `functools.reduce(lambda ${accVar}, ${elemVar}${LAMBDA_COLON_PLACEHOLDER} ${loweredBody}, ${receiver}[::-1], ${seed})`;
                         }
                         else {
@@ -365,8 +459,8 @@ function lowerJsArrayMethods(expr, imports) {
                     if (arrow && arrow.params.length >= 2) {
                         const a = arrow.params[0];
                         const b = arrow.params[1];
-                        const body = lowerJsArrayMethods(arrow.body, imports);
-                        imports?.add('import functools');
+                        const body = lowerJsArrayMethods(arrow.body, ctx);
+                        ctx.imports?.add('import functools');
                         lowered = `sorted(${receiver}, key=functools.cmp_to_key(lambda ${a}, ${b}${LAMBDA_COLON_PLACEHOLDER} ${body}))`;
                     }
                     else {
@@ -380,14 +474,9 @@ function lowerJsArrayMethods(expr, imports) {
                 else if (method === 'at') {
                     const n = args[0] ?? '0';
                     lowered = `(${receiver}[${n}] if -len(${receiver}) <= ${n} < len(${receiver}) else None)`;
-                }
-                else if (method === 'reverse') {
-                    // JS reverses in place AND returns the array; we only need the value.
-                    lowered = `${receiver}[::-1]`;
-                }
-                else if (method === 'concat') {
-                    // array args only (scalar-arg concat is out of scope)
-                    lowered = args.length ? `(${receiver} + ${args.join(' + ')})` : `${receiver}[:]`;
+                    // NB: `reverse` and `concat` are handled earlier in this chain (they mutate /
+                    // accept scalar args per JS) — main's later array-only duplicates were dropped
+                    // in the roadmap-stack merge (they were dead + concat broke on scalar args).
                 }
                 else if (method === 'fill') {
                     const v = args[0] ?? 'None';
@@ -1776,7 +1865,20 @@ function lowerPortableJsOperators(expr, imports) {
     result = replaceJsOperator(result, '??', looseBinaryStops, (l, r) => `(${l} if ${l} is not None else ${r})`);
     return result;
 }
-export function rewriteFastAPIExpr(expr, pathParams, bodyFields = new Set(), authUser = false, imports) {
+export function rewriteFastAPIExpr(expr, pathParams, bodyFields = new Set(), authUser = false, imports, hoistedDefs, closureSeq) {
+    try {
+        const tokens = tokenizeJSExpr(expr);
+        const comparisonProbe = expr.replace(/>>>|>>|<</g, '');
+        const hasLooseComparison = /(?:===|!==|==|!=|<=|>=|<|>)/.test(comparisonProbe);
+        const hasBitwiseOrModulo = !expr.includes('=>') && !hasLooseComparison && tokens.some((t) => t.type === 'UNARY' || t.type === 'OP');
+        if (hasBitwiseOrModulo) {
+            const ast = parseTokens(tokens);
+            expr = codegenASTToPython(ast, imports);
+        }
+    }
+    catch (_err) {
+        // Graceful fallback to original expr string if parsing/emission fails
+    }
     const { maskedExpr, replacements } = extractTemplateLiterals(expr, pathParams, bodyFields, authUser, imports);
     let result = maskedExpr;
     // Spread → unpacking first, so the request-ref rewrites below see clean
@@ -1832,7 +1934,7 @@ export function rewriteFastAPIExpr(expr, pathParams, bodyFields = new Set(), aut
     // Array methods first (so any `===` inside an arrow body is hoisted into
     // a list-comprehension predicate that the strict-equality pass below
     // then catches).
-    result = lowerJsArrayMethods(result, imports);
+    result = lowerJsArrayMethods(result, { pathParams, bodyFields, authUser, imports, hoistedDefs, closureSeq });
     // Strict equality: skip text inside quoted strings so a user message
     // like `"use === for strict equality"` doesn't get mangled to `==`.
     result = result.replace(STRICT_EQ_RE, (match) => {
@@ -1919,4 +2021,250 @@ export function addRespondImports(respondNode, imports) {
     if (rp.error)
         imports.add('from fastapi import HTTPException');
 }
+function tokenizeJSExpr(expr) {
+    const tokens = [];
+    let i = 0;
+    while (i < expr.length) {
+        while (i < expr.length && /\s/.test(expr[i])) {
+            i++;
+        }
+        if (i >= expr.length)
+            break;
+        const char = expr[i];
+        if (char === '(') {
+            tokens.push({ type: 'LP' });
+            i++;
+            continue;
+        }
+        if (char === ')') {
+            tokens.push({ type: 'RP' });
+            i++;
+            continue;
+        }
+        if (char === '~') {
+            tokens.push({ type: 'UNARY', value: '~' });
+            i++;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            const quote = char;
+            let val = quote;
+            i++;
+            while (i < expr.length) {
+                const c = expr[i];
+                val += c;
+                if (c === '\\') {
+                    val += expr[i + 1] ?? '';
+                    i += 2;
+                    continue;
+                }
+                if (c === quote) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            tokens.push({ type: 'TEXT', value: val });
+            continue;
+        }
+        if (char === '&') {
+            if (expr[i + 1] === '&') {
+                // Fall through to TEXT
+            }
+            else {
+                tokens.push({ type: 'OP', value: '&' });
+                i++;
+                continue;
+            }
+        }
+        if (char === '|') {
+            if (expr[i + 1] === '|') {
+                // Fall through to TEXT
+            }
+            else {
+                tokens.push({ type: 'OP', value: '|' });
+                i++;
+                continue;
+            }
+        }
+        if (char === '^' || char === '%') {
+            tokens.push({ type: 'OP', value: char });
+            i++;
+            continue;
+        }
+        if (char === '<' && expr[i + 1] === '<') {
+            tokens.push({ type: 'OP', value: '<<' });
+            i += 2;
+            continue;
+        }
+        // `>>>` (unsigned right shift) is intentionally OUT of the int32 AST path
+        // (deferred — see the numbermodel oracle note). Bail the whole expr out of
+        // the AST path by throwing (caught in rewriteFastAPIExpr) so the downstream
+        // string-level operator lowering — which 32-bit-masks `>>>` correctly —
+        // handles it. Must be checked BEFORE `>>`, else `>>` greedily eats two of
+        // the three `>` and leaves a stray `>` that mangles the operand.
+        if (char === '>' && expr[i + 1] === '>' && expr[i + 2] === '>') {
+            throw new Error('unsupported-operator: >>> (defer to string lowering)');
+        }
+        if (char === '>' && expr[i + 1] === '>') {
+            tokens.push({ type: 'OP', value: '>>' });
+            i += 2;
+            continue;
+        }
+        let text = '';
+        while (i < expr.length) {
+            const c = expr[i];
+            if (c === '(' || c === ')' || c === '~' || c === '^' || c === '%') {
+                break;
+            }
+            if (c === '"' || c === "'" || c === '`') {
+                break;
+            }
+            if (c === '&') {
+                if (expr[i + 1] === '&') {
+                    text += '&&';
+                    i += 2;
+                    continue;
+                }
+                else {
+                    break;
+                }
+            }
+            if (c === '|') {
+                if (expr[i + 1] === '|') {
+                    text += '||';
+                    i += 2;
+                    continue;
+                }
+                else {
+                    break;
+                }
+            }
+            if (c === '<' && expr[i + 1] === '<') {
+                break;
+            }
+            if (c === '>' && expr[i + 1] === '>') {
+                break;
+            }
+            text += c;
+            i++;
+        }
+        if (text) {
+            tokens.push({ type: 'TEXT', value: text.trimEnd() });
+        }
+    }
+    return tokens;
+}
+function parseTokens(tokens) {
+    let index = 0;
+    function peek() {
+        return tokens[index];
+    }
+    function consume() {
+        return tokens[index++];
+    }
+    function getPrecedence(op) {
+        switch (op) {
+            case '|':
+                return 1;
+            case '^':
+                return 2;
+            case '&':
+                return 3;
+            case '<<':
+            case '>>':
+                return 4;
+            case '%':
+                return 5;
+            default:
+                return 0;
+        }
+    }
+    function parseExpression(precedence) {
+        let left = parsePrimary();
+        while (true) {
+            const next = peek();
+            if (!next || next.type !== 'OP')
+                break;
+            const opPrecedence = getPrecedence(next.value);
+            if (opPrecedence < precedence)
+                break;
+            consume();
+            const right = parseExpression(opPrecedence + 1);
+            left = { type: 'binary', op: next.value, left, right };
+        }
+        return left;
+    }
+    function parsePrimary() {
+        const t = peek();
+        if (!t)
+            throw new Error('Unexpected EOF');
+        if (t.type === 'UNARY') {
+            consume();
+            const arg = parseExpression(6);
+            return { type: 'unary', op: t.value, arg };
+        }
+        if (t.type === 'LP') {
+            consume();
+            const inner = parseExpression(0);
+            const next = peek();
+            if (next && next.type === 'RP') {
+                consume();
+            }
+            return { type: 'group', arg: inner };
+        }
+        if (t.type === 'TEXT') {
+            consume();
+            return { type: 'text', value: t.value };
+        }
+        consume();
+        return { type: 'text', value: t.type === 'OP' ? t.value : '' };
+    }
+    return parseExpression(0);
+}
+function codegenASTToPython(node, imports) {
+    switch (node.type) {
+        case 'text':
+            return node.value;
+        case 'group':
+            return `(${codegenASTToPython(node.arg, imports)})`;
+        case 'unary': {
+            const argStr = codegenASTToPython(node.arg, imports);
+            if (node.op === '~') {
+                imports?.add(KERN_I32_HELPER_PY);
+                return `_i32(~_i32(${argStr}))`;
+            }
+            return `${node.op}${argStr}`;
+        }
+        case 'binary': {
+            const leftStr = codegenASTToPython(node.left, imports);
+            const rightStr = codegenASTToPython(node.right, imports);
+            if (node.op === '|') {
+                imports?.add(KERN_I32_HELPER_PY);
+                return `_i32(_i32(${leftStr}) | _i32(${rightStr}))`;
+            }
+            if (node.op === '&') {
+                imports?.add(KERN_I32_HELPER_PY);
+                return `_i32(_i32(${leftStr}) & _i32(${rightStr}))`;
+            }
+            if (node.op === '^') {
+                imports?.add(KERN_I32_HELPER_PY);
+                return `_i32(_i32(${leftStr}) ^ _i32(${rightStr}))`;
+            }
+            if (node.op === '<<') {
+                imports?.add(KERN_I32_HELPER_PY);
+                return `_i32(_i32(${leftStr}) << (_i32(${rightStr}) & 31))`;
+            }
+            if (node.op === '>>') {
+                imports?.add(KERN_I32_HELPER_PY);
+                return `_i32(_i32(${leftStr}) >> (_i32(${rightStr}) & 31))`;
+            }
+            if (node.op === '%') {
+                imports?.add(KERN_TMOD_HELPER_PY);
+                return `_tmod(${leftStr}, ${rightStr})`;
+            }
+            return `${leftStr} ${node.op} ${rightStr}`;
+        }
+    }
+}
 //# sourceMappingURL=fastapi-response.js.map