@kernlang/core 3.3.9 → 3.4.1

package/dist/codegen/type-system.d.ts

@@ -3,10 +3,122 @@
  *
  * Extracted from codegen-core.ts for modular codegen architecture.
  */
-import type { IRNode } from '../types.js';
+import { type IRNode } from '../types.js';
 export declare function generateType(node: IRNode): string[];
 export declare function generateInterface(node: IRNode): string[];
 export declare function generateUnion(node: IRNode): string[];
 export declare function generateClass(node: IRNode): string[];
 export declare function generateService(node: IRNode): string[];
+export declare function generateEnum(node: IRNode): string[];
 export declare function generateConst(node: IRNode): string[];
+/**
+ * Slice 3d — emit a TS destructuring statement from a `destructure` node.
+ *
+ * Two paths:
+ *   (1) `expr={{...}}` escape hatch — emit the carried code verbatim. Used
+ *       by the importer for complex patterns (rest `...`, defaults `=v`,
+ *       nested `{a:{b}}`, computed keys) where structured children would
+ *       lose information.
+ *   (2) Structured children — `binding` for object patterns (with optional
+ *       `key=` for renames) or `element` for array patterns (with `index=`
+ *       for ordered position). Codegen detects which child kind dominates
+ *       and emits `{a, b: alias} = src` or `[a, b, , c] = src` (holes from
+ *       index gaps).
+ *
+ * `kind` defaults to `const` when omitted. `type` (optional) flows through
+ * `emitTypeAnnotation` and is appended after the LHS pattern.
+ */
+export declare function generateDestructure(node: IRNode): string[];
+/**
+ * Slice 3c-extension #3 / shared with slice 3d destructure: format the LHS
+ * pattern (`{a, b: alias}` or `[x, , y]`) from a node's `binding` (object)
+ * or `element` (array) children. Returns null when neither is present (used
+ * by the destructure node validator); throws when the node mixes both.
+ *
+ * Used by:
+ *  - `generateDestructure` (slice 3d) — full statement: `const {a,b} = src;`
+ *  - `parseParamListFromChildren` (slice 3c-extension #3) — pattern-only LHS
+ *    of a destructured fn parameter: `{a, b}: Point` or `[x, y]`.
+ */
+export declare function formatBindingPatternFromChildren(node: IRNode): string | null;
+/**
+ * Slice 3e — emit a TS Map literal from a `mapLit` node.
+ *
+ *   mapLit name=cache type="Map<string, number>"
+ *     mapEntry key="foo" value=1
+ *     mapEntry key="bar" value=2
+ *
+ * → `const cache: Map<string, number> = new Map([['foo', 1], ['bar', 2]]);`
+ *
+ * `expr={{...}}` escape hatch carries a raw TS statement verbatim — used
+ * by the importer fallback when a Map literal contains shapes the
+ * structured emitter can't represent (computed keys, conditional entries,
+ * spread). Mirrors slice 3d destructure escape-hatch policy.
+ */
+export declare function generateMapLit(node: IRNode): string[];
+/**
+ * Slice 3e — emit a TS Set literal from a `setLit` node.
+ *
+ *   setLit name=allowed type="Set<string>"
+ *     setItem value="admin"
+ *     setItem value="user"
+ *
+ * → `const allowed: Set<string> = new Set(['admin', 'user']);`
+ *
+ * Same `expr={{...}}` escape-hatch policy as `mapLit`/`destructure`.
+ */
+export declare function generateSetLit(node: IRNode): string[];
+/** Emit the right-hand side of an expression-typed prop (e.g. `const.value`,
+ *  `let.value`) from its raw IR form.
+ *
+ *  - `<prop>={{ expr }}` (ExprObject) — emit `.code` raw (escape hatch for arbitrary TS).
+ *  - `<prop>="literal"` (quoted, tracked in __quotedProps) — emit as JSON-quoted string
+ *    so output is valid TS even when the literal contains expression-illegal characters.
+ *  - bare `<prop>=...` — try ValueIR parse + emit for canonicalization. Fall back to raw
+ *    string on parse failure (validator emits INVALID_EXPRESSION but codegen still ships).
+ *
+ *  Slice 3e — `propName` parameter (default 'value') lets non-`value` props
+ *  participate in the same quoted-vs-bare distinction. `mapEntry.key` and
+ *  `mapEntry.value` both flow through this with their own __quotedProps key. */
+export declare function emitConstValue(node: IRNode, rawValue: unknown, propName?: string): string;
+/**
+ * Slice 3c — produce a TS parameter-list string from `param` child IR nodes.
+ *
+ * Mirrors `parseParamList` (which parses the legacy `params="..."` string)
+ * but reads structured child nodes so each parameter's `value=` flows through
+ * `emitConstValue` for ValueIR canonicalisation. Identifier/type annotations
+ * are routed through the schema emitters so authored bad input raises
+ * KernCodegenError instead of producing broken TS.
+ *
+ * Per child:
+ *   - `value=` (slice 3c, ValueIR-canonicalised) — JSON-quoted for quoted
+ *     string literals, parsed+re-emitted for bare expressions, raw for
+ *     `{{...}}` ExprObject. Same routing as slice 3b field.value.
+ *   - `default=` (rawExpr passthrough) — kept for back-compat / MCP usage.
+ *   - When both set, `value` wins. The slice 3a/3b gate treats unquoted
+ *     empty `value=` as absent so it doesn't trigger the
+ *     `parseExpression('')` throw → empty fallback → `name: T = ;` bug.
+ *
+ * `options.stripDefaults`: TS forbids parameter initializers in overload
+ * signatures — the implementation alone may carry defaults. Same flag as
+ * the sibling `parseParamList`.
+ */
+export declare function parseParamListFromChildren(paramNodes: IRNode[], options?: {
+    stripDefaults?: boolean;
+}): string;
+/**
+ * Slice 3c — unified TS parameter-list emitter for any callable IR node.
+ *
+ * Reads the node's `param` children first (canonical, ValueIR-routed). If
+ * none, falls back to the legacy `params="..."` string. If neither, returns
+ * the fallback (default empty).
+ *
+ * Children win when present. Mixed mode is intentionally unsupported — a
+ * signature is either fully-structured-children or fully-legacy-string.
+ * Producers (importer, migrate-class-body) emit children all-or-nothing
+ * per signature; consumers don't need to reconcile partial states.
+ */
+export declare function emitParamList(node: IRNode, options?: {
+    stripDefaults?: boolean;
+    fallback?: string;
+}): string;