@kernlang/python 3.5.9-canary.218.1.77aa9b0c → 4.0.0

package/dist/codegen-body-python.d.ts

@@ -51,6 +51,15 @@ export interface BodyEmitOptions {
      *  the KERN-form `userId` resolves to the snake_cased Python parameter.
      *  Identifiers not in the map pass through unchanged. */
     symbolMap?: Record<string, string>;
+    /** When true, the handler is a class member body: identifier `super`
+     *  lowers to Python `super()` (so `super.m()` -> `super().m()`) and a
+     *  direct `super(...)` call lowers to `super().__init__(...)`. Paired with
+     *  a `symbolMap` entry `this -> self` by the class generator. */
+    inClassBody?: boolean;
+    /** When true, the handler is specifically a constructor body, so a direct
+     *  `super(...)` call lowers to `super().__init__(...)`. Outside a constructor
+     *  `super(...)` is not a parent-constructor call and is left untouched. */
+    inConstructor?: boolean;
     /** Slice 4a review fix (Gemini #5) — how to lower the `?` propagation
      *  hoist's err-branch return:
      *    - 'value' (default for `fn`): `return __k_tN` so the caller sees
@@ -75,6 +84,16 @@ export interface BodyEmitOptions {
         forIterNext?: boolean;
         letAssign?: boolean;
     };
+    /** Coercion-slice opt-out for the helper-less Ground/React declarative
+     *  layer. Defaults to `true` (native KERN bodies + expression unit tests
+     *  get full JS value→string coercion, injecting helpers function-locally).
+     *  The Ground generators (`coalesce`/`firstDefined`/`firstTruthy`/`objectMerge`
+     *  /…) emit module-level statements via `emitPyExpression` and have no
+     *  channel to define `_kern_fmt`/`__kern_add`/`_KERN_UNDEFINED`, so they pass
+     *  `false` to keep the pre-slice output (zero regression). Extending coercion
+     *  to the Ground layer needs module-level (single-definition) helper
+     *  injection — a separate follow-up. */
+    coerceJsValues?: boolean;
     /** Outer-scope names the body INHERITS — typically function parameters and
      * module-level globals the wrapper has bound. Pre-populated as the
      * outermost `localScopes` map so an inner-block `let` that shadows ANY of
@@ -108,6 +127,11 @@ export interface BodyEmitResult {
     usedPropagation: boolean;
     helpers: Set<string>;
 }
+export interface PyExpressionEmitResult {
+    code: string;
+    imports: Set<string>;
+    helpers: Set<string>;
+}
 interface BodyEmitContext {
     gensymCounter: number;
     imports: Set<string>;
@@ -116,6 +140,8 @@ interface BodyEmitContext {
      *  `each` pair-mode). Consumer emits each entry at module scope. */
     helpers: Set<string>;
     symbolMap: Record<string, string>;
+    inClassBody: boolean;
+    inConstructor: boolean;
     shadowedSymbols: Set<string>;
     localScopes: Array<Map<string, 'const' | 'let' | 'cell'>>;
     regexScopes: Array<Map<string, Extract<ValueIR, {
@@ -146,6 +172,65 @@ interface BodyEmitContext {
      *  override pending control flow, so it gets a finally-specific error. */
     finallyDepth: number;
     standaloneExpression: boolean;
+    /** When true, helper-dependent JS value→string coercion is emitted
+     *  (`__kern_add`, `_kern_fmt`-wrapped templates, the `_KERN_UNDEFINED`
+     *  sentinel + sentinel-aware `??`/`typeof`). Native KERN bodies inject the
+     *  required helpers function-locally, so the default is true. The Ground/
+     *  React declarative layer (`coalesce`/`firstDefined`/etc.) emits module-
+     *  level statements through `emitPyExpression` with NO per-statement helper
+     *  channel, so it opts out and keeps the pre-coercion-slice forms (raw `+`,
+     *  raw f-string interpolation, `None` for undefined, None-only `??`).
+     *  See BodyEmitOptions.coerceJsValues. */
+    coerceJsValues: boolean;
+    /** Slices 0+1 — block-bodied arrow closure lowering. When `emitLambdaPy`
+     *  lowers a block arrow it pushes a hoisted local `def __kern_closure_N(...)`
+     *  (a block of source lines) here and returns the def's NAME as the
+     *  expression string. `emitChildrenPy`'s per-child loop flushes the buffer
+     *  IMMEDIATELY BEFORE the statement that referenced it (at the current
+     *  indent), so the def precedes its use even inside if/else/loop bodies. A
+     *  buffer left non-empty when a handler body finishes is a BUG (defensive
+     *  throw at the body-emit entry point). */
+    pendingHoists: string[][];
+    /** Monotonic gensym counter for hoisted closure def names. Separate from
+     *  `gensymCounter` so closure names stay stable/independent of other
+     *  gensym usage. */
+    closureSeq: number;
+    /** Slice-2 loop-variable pinning. Each entry is the INDEX into `localScopes`
+     *  of a scope that is a loop BODY (an `each`/`for`/`while` body). A captured
+     *  name is pinned (JS per-iteration capture → Python default arg) IFF its
+     *  binding resolves at an index `>= loopScopeIndexes[0]` — i.e. at or inside
+     *  the OUTERMOST enclosing loop body. Bindings declared OUTSIDE every loop
+     *  (function params, accumulators, a `while` condition var) resolve below
+     *  `loopScopeIndexes[0]` and stay late-bound (already JS-parity-correct).
+     *  Pushed on loop-body entry, popped on exit (LIFO, mirrors `localScopes`). */
+    loopScopeIndexes: number[];
+    /** Slice-2 fix (agon review, claude 0.7) — one frame per active loop body,
+     *  parallel to `loopScopeIndexes`. `assignLast` maps a bare assign-target
+     *  name to the LAST top-level child index (within that loop body) whose
+     *  subtree assigns it; `current` is the child index the loop body is
+     *  emitting right now. The default-arg pin freezes a capture at def time,
+     *  but JS captures BY REFERENCE — so a pinned per-iteration binding that is
+     *  REASSIGNED in a LATER sibling statement diverges (JS sees the mutation,
+     *  the frozen default does not). Such captures fail closed at emission
+     *  instead of emitting silently wrong values. Because within-child statement
+     *  order is NOT tracked (the whole top-level child shares one index), the
+     *  reject is `>=` (not `>`): a reassignment in the SAME top-level child as the
+     *  closure also fails closed (it cannot be proven to run before the closure).
+     *  `assignLast` covers both `assign` (incl. compound/postfix `op=` forms, same
+     *  node type) and `set` (a bare-name cell write).
+     *
+     *  Mutation-v1 note: this sibling-reassignment check applies ONLY to PINNED
+     *  candidates (per-iteration loop-locals that pin via a default arg). A
+     *  free-variable WRITE inside a closure body (`emitBlockClosurePy`'s
+     *  `nonlocal` path) targets an OUTER binding declared below the outermost
+     *  loop scope, so it is never a pin candidate and never enters this frame —
+     *  the `>=` reject cannot misfire on a nonlocal-written capture. (A write to a
+     *  binding that IS a per-iteration capture is rejected earlier as
+     *  `closure-pinned-write`, so the two paths stay disjoint.) */
+    loopLaterAssignFrames: Array<{
+        assignLast: Map<string, number>;
+        current: number;
+    }>;
 }
 /** PR-4 — Python helpers that normalize `each` pair-mode iteration sources.
  *  Co-located with the codegen so the production emitter and the differential
@@ -213,6 +298,7 @@ export declare function emitNativeKernBodyPythonWithImports(handlerNode: IRNode,
  *  `emitPyExprCtx` which threads the live ctx (and therefore the live
  *  imports set) end-to-end. */
 export declare function emitPyExpression(node: ValueIR, options?: BodyEmitOptions): string;
+export declare function emitPyExpressionWithImports(node: ValueIR, options?: BodyEmitOptions): PyExpressionEmitResult;
 export declare function lowerBitwiseAndModuloAST(node: ValueIR): ValueIR;
 export declare function registerHelpers(node: ValueIR, ctx: BodyEmitContext): void;
 export {};