@scriptc/compiler 0.3.6 → 0.4.0

package/dist/backend/llvm/emit-function.d.ts

@@ -0,0 +1,64 @@
+import { type LlArgPackAndTrampolinePrologue, type LlEmitter } from "./emitter.js";
+import { type IrFunction } from "../../ir/ir.js";
+import type { LlValue } from "./expr-context.js";
+export declare function emitFunction(emitter: LlEmitter, fn: IrFunction): string;
+/** Per-generator-function machinery — the async scaffolding's lazy
+ * sibling (async.ts's emitGenScaffolding): the same argument pack,
+ * a fiber trampoline whose epilogue stores the COMPLETION value (or
+ * consumes the GENRET sentinel, promoting the parked .return value), a
+ * spawn wrapper that only ALLOCATES the suspended fiber, and the
+ * never-started teardown that drops the packed (+1) arguments. */
+export declare function emitGenScaffolding(emitter: LlEmitter): string[];
+/** Per-async-function machinery — async.ts's scaffolding, .ll
+ * flavored: an argument-pack struct type, a fiber trampoline (unpacks,
+ * frees the pack, runs the ordinary compiled body, settles the
+ * promise — fulfilling on clean return, leaving a pending exception
+ * for the runtime to reject with), and a spawn wrapper call sites and
+ * closures enter through (packs the args +1, scr_async_spawn runs the
+ * fiber eagerly to its first suspension and returns the promise). */
+export declare function emitAsyncScaffolding(emitter: LlEmitter): string[];
+/** The await-call entry of an async function (`sc_aw_*`): one direct
+ * `await f(...)` as a call returning the awaited value, so the call site
+ * needs no promise of its own. A fiberless body runs on the caller's
+ * stack as in its spawn wrapper; a clean result then takes the await's
+ * one microtask turn (scr_await_hop) and is returned without ever
+ * materializing the promise, which nothing else could observe. A throw
+ * builds the rejected promise exactly as the spawn wrapper would and
+ * awaits it, so the rejection reaches the awaiter on the same turn. Other
+ * bodies pack their arguments as the spawn wrapper does and enter
+ * scr_async_spawn_await_*, which parks the caller on the promise as soon
+ * as the body first suspends. The adopting entry (`sc_ad_*`, for
+ * `return f(...)` in an async function) adds the turn of the then job
+ * that adopts the returned promise, before the await proper. */
+export declare function emitAsyncAwaitCall(emitter: LlEmitter, fn: IrFunction, argPackLines: string[] | null, adopt: boolean): string[];
+/** Move a clean async return value into the current fiber's promise. */
+export declare function emitWasiFulfill(emitter: LlEmitter, v: LlValue | null): void;
+/** The argument-pack ABI and trampoline prefix shared by async functions
+ * and generators. Their promise/generator completion and spawn tails stay
+ * with the callers below. */
+export declare function emitArgPackAndTrampolinePrologue(emitter: LlEmitter, fn: IrFunction): LlArgPackAndTrampolinePrologue;
+/** The module functions whose bodies may park their execution context:
+ * their emitted text mentions a suspension entry point (SUSPENDS), or
+ * they mention such a function (transitively). Null where async bodies
+ * must keep fibers regardless: wasm32 (its coroutine lowering owns async
+ * bodies), worker programs, and programs that use node:test subtests,
+ * whose `t.test()` awaits on the CURRENT fiber even from synchronous
+ * code. */
+export declare function parkingFunctions(emitter: LlEmitter): Set<string> | null;
+/** Async functions whose calls can skip the fiber (scr_async_inline_*).
+ * A body qualifies only when nothing it runs can park its execution
+ * context: its emitted text, and the text of every module function it
+ * mentions (transitively), contains no suspension entry point. Such a
+ * body always completes before the call returns, which is exactly the
+ * behavior of a fiber that never suspends. Excluded conservatively:
+ * wasm32 (its coroutine lowering owns async bodies), module-evaluation
+ * bodies (their promise caches),
+ * `dyn` results (resolution may adopt a thenable), and every program
+ * that uses node:test subtests — `t.test()` runs a subtest inline and
+ * awaits it on the CURRENT fiber even from synchronous code. Worker
+ * programs keep fibers too: their fiber epilogue owns context
+ * termination (a stopping worker rejects and observes the promise), which
+ * the fiberless wrapper does not reproduce. A missed suspension still
+ * cannot reorder execution undetected: the runtime traps when a context parks while a
+ * fiberless body is on its stack. */
+export declare function fiberlessAsyncFunctions(emitter: LlEmitter): Set<string>;