@scriptc/compiler 0.0.0 → 0.0.1

package/dist/backend/llvm/shapes.d.ts

@@ -0,0 +1,78 @@
+import type { IrModule, IrRecordShape, IrType } from "../../ir/nodes.js";
+/** What the tables need from the emitter: the extern-declaration ledger
+ * and the module-wide cycle/shape indexes. */
+export interface ShapeHost {
+    declare(decl: string): void;
+    /** Request the shared OOM abort helper (@sc_oom) — emitted once. */
+    needOom(): void;
+    readonly tracedShapes: Set<string>;
+    readonly tracedUnions: Set<string>;
+    readonly recordsById: Map<string, IrRecordShape>;
+}
+/** Every emitted function/helper carries #0 = { sanitize_address } — see
+ * the emitter header. */
+export declare const FN_ATTRS = "#0";
+export declare function computeTraced(mod: IrModule): {
+    shapes: Set<string>;
+    unions: Set<string>;
+};
+/** The runtime's `_v` (ptr → ptr / ptr → void) RC entry points for one
+ * refcounted type — used both as the CALL targets of the LLVM tier's
+ * retain/release (everything is `ptr` here, so the `_v` shape IS the
+ * direct shape) and as the function-pointer arguments of every container
+ * construction (unions, ref arrays, obj boxes, overflow maps). Records
+ * use their emitted per-shape helpers, whose signatures are already
+ * `_v`-shaped. */
+export declare function vAdapters(host: ShapeHost, t: IrType): {
+    retain: string;
+    release: string;
+};
+/** The retain call target (ptr → ptr, +1 unless immortal) — the `_v`
+ * table above; the split exists so call sites read type-directedly. */
+export declare function retainSym(host: ShapeHost, t: IrType): string;
+/** The release call target (ptr → void, NULL-tolerant). The runtime's
+ * typed releases are external symbols, so the direct (non-`_v`) entry
+ * points serve where one exists; records use their emitted helper. */
+export declare function releaseSym(host: ShapeHost, t: IrType): string;
+/** The trace entry point for a payload/field type, or null when the type
+ * cannot participate in a cycle — traceAdapterC's table over the LLVM
+ * tier's kinds (promise/object rows are out of tier and unreachable:
+ * their RC rows refuse first). */
+export declare function traceAdapter(host: ShapeHost, t: IrType): string | null;
+/** `@trace` or `null` — the trace argument at a container call site. */
+export declare function traceArg(host: ShapeHost, t: IrType): string;
+/** Runtime accessor suffix for an element type (matches emit-types.ts:
+ * f64 and bool unboxed, everything refcounted through the `_ref` family). */
+export declare function elemAccess(elem: IrType): "f64" | "bool" | "ref";
+/** Array construction call text (arrNewC's dispatch): ref elements
+ * (records, unions, closures — and cycle-capable inner arrays, whose
+ * SCR_ELEM_ARR spelling would hide them from the outer array's trace)
+ * construct through scr_arr_new_ref with the element type's `_v` RC entry
+ * points; every other element kind keeps the plain scr_arr_new call. */
+export declare function arrNewCall(host: ShapeHost, elem: IrType, capText: string): string;
+/** Box construction call text (boxNewC's dispatch): plain-kind boxes for
+ * the runtime-known payloads, obj-kind boxes (RC entry points + trace as
+ * data) for per-shape payloads and cycle-capable arrays. SCR_BOX_* tags
+ * from scr_runtime.h. */
+export declare function boxNewCall(host: ShapeHost, t: IrType): string;
+/** Box accessor suffix (boxAccess): scalars unboxed, ref kinds pointers. */
+export declare function boxAccess(t: IrType): "f64" | "bool" | "ref";
+/** A record field's in-struct LLVM type. bool fields store as i8 (the C
+ * _Bool layout); loads/stores convert at the access site. */
+export declare function llFieldType(t: IrType): "double" | "i8" | "ptr";
+/** Runtime suffix for a map's KEY kind (mapKeyAccess's table): f64 with
+ * SameValueZero, string content, or handle-identity REF (symbols). */
+export declare function mapKeyAccess(key: IrType): "f64" | "str" | "ref";
+/** The ScrMapKeyKind / ScrMapValKind constants for scr_map_new. */
+export declare function mapKeyKindNum(key: IrType): number;
+export declare function mapValKindNum(value: IrType): number;
+/** Per-record-shape LLVM emission: the named struct types (returned as
+ * `typeDefs`) and the new/retain/release (+trace/gcFree for cycle-capable
+ * shapes) function definitions (`defs`). Layout mirrors the C emitter:
+ * `{ i64 rc, fields..., [ptr overflow] }`; the retain/release signatures
+ * are already `_v`-shaped, so the same symbols serve as container RC
+ * entry points. */
+export declare function emitRecordShapes(host: ShapeHost, mod: IrModule): {
+    typeDefs: string[];
+    defs: string[];
+};