@scriptc/compiler 0.0.36 → 0.1.1

package/ambient/scriptc-node-fallback.d.ts

@@ -921,15 +921,17 @@ declare module "module" {
   export * from "node:module";
 }
 /* import.meta: module-loader metadata with no value representation —
- * every read fences (SC1090) EXCEPT as createRequire's base, where it
- * only NAMES the containing file (import.meta.url, import.meta.filename,
- * and __filename all mean "this file" there). Declared so the pattern
- * typechecks under the fallback surface; @types/node's own augmentation
- * stands in when adopted. */
+ * direct file-backed fields lower to constants, while the object and
+ * remaining members fence (SC1090) EXCEPT as createRequire's base, where it
+ * only NAMES the containing file. Declared so unsupported forms reach their
+ * named lowering fences; @types/node's own augmentation stands in when
+ * adopted. */
 interface ImportMeta {
   url: string;
   filename: string;
   dirname: string;
+  main: boolean;
+  resolve(specifier: string, parent?: string | URL): string;
 }
 
 /* The synchronous node:fs surface — utf8-only, no options objects, no

package/ambient/scriptc-overrides.d.ts

@@ -13,13 +13,6 @@
  * primitives every world needs (comptime, setTimeout, __island_eval) live
  * in scriptc.d.ts, which ships to BOTH programs. */
 
-/* `pop(): T`, not the lib's `T | undefined`: popping an empty array traps
- * at runtime — a documented divergence (SEMANTICS.md) this override keeps
- * typecheckable. Check `.length` first, as real code must. */
-interface Array<T> {
-  pop(): T;
-}
-
 /* `at(): string`, not the lib's `string | undefined`: undefined is
  * unrepresentable, so an out-of-range at() THROWS a catchable TypeError at
  * the validated island exit instead of returning undefined (documented

package/ambient/scriptc.d.ts

@@ -15,7 +15,7 @@
  * This file ships to EVERY program scriptc builds — the lowering program
  * and preflight's project-world second-chance program alike (a project
  * using comptime must typecheck in both). The divergence/precision
- * overrides (JSON.parse(): unknown, pop(): T, the Promise executor shape,
+ * overrides (JSON.parse(): unknown, the Promise executor shape,
  * ...) live in scriptc-overrides.d.ts, which joins the LOWERING program only.
  *
  * console, process, and the "node:fs" module live in scriptc-node-fallback.d.ts,

package/dist/backend/c/exprs.js

@@ -17,7 +17,7 @@ function streamTypedRefCommitAdapter(emitter, t, snapshot, defs) {
     if (t.kind === "array") {
         const commit = `${snapshot}_commit`;
         emitter.walkerProtos.push(`static void ${commit}(void *sc_p, const ScrDyn *sc_d); /* commit live stream element ${typeKey(t)} */`);
-        defs.push(`static void ${commit}(void *sc_p, const ScrDyn *sc_d) {`, `  ScrArr *sc_target = (ScrArr *)sc_p;`, `  ScrArr *sc_next = ${emitter.dynCheckHelper(t)}(sc_d, NULL);`, `  if (!sc_next) return;`, `  size_t sc_target_len = sc_target->len;`, `  size_t sc_target_cap = sc_target->cap;`, `  uint64_t *sc_target_data = sc_target->data;`, `  sc_target->len = sc_next->len;`, `  sc_target->cap = sc_next->cap;`, `  sc_target->data = sc_next->data;`, `  sc_next->len = sc_target_len;`, `  sc_next->cap = sc_target_cap;`, `  sc_next->data = sc_target_data;`, `  scr_arr_release(sc_next);`, `}`, ``);
+        defs.push(`static void ${commit}(void *sc_p, const ScrDyn *sc_d) {`, `  ScrArr *sc_target = (ScrArr *)sc_p;`, `  ScrArr *sc_next = ${emitter.dynCheckHelper(t)}(sc_d, NULL);`, `  if (!sc_next) return;`, `  size_t sc_target_len = sc_target->len;`, `  size_t sc_target_cap = sc_target->cap;`, `  uint64_t *sc_target_data = sc_target->data;`, `  uint8_t *sc_target_present = sc_target->present;`, `  ScrArrSparseSlot *sc_target_sparse = sc_target->sparse;`, `  size_t sc_target_sparse_len = sc_target->sparse_len;`, `  size_t sc_target_sparse_cap = sc_target->sparse_cap;`, `  ScrArrProp *sc_target_props = sc_target->props;`, `  size_t sc_target_prop_len = sc_target->prop_len;`, `  size_t sc_target_prop_cap = sc_target->prop_cap;`, `  sc_target->len = sc_next->len;`, `  sc_target->cap = sc_next->cap;`, `  sc_target->data = sc_next->data;`, `  sc_target->present = sc_next->present;`, `  sc_target->sparse = sc_next->sparse;`, `  sc_target->sparse_len = sc_next->sparse_len;`, `  sc_target->sparse_cap = sc_next->sparse_cap;`, `  sc_target->props = sc_next->props;`, `  sc_target->prop_len = sc_next->prop_len;`, `  sc_target->prop_cap = sc_next->prop_cap;`, `  sc_next->len = sc_target_len;`, `  sc_next->cap = sc_target_cap;`, `  sc_next->data = sc_target_data;`, `  sc_next->present = sc_target_present;`, `  sc_next->sparse = sc_target_sparse;`, `  sc_next->sparse_len = sc_target_sparse_len;`, `  sc_next->sparse_cap = sc_target_sparse_cap;`, `  sc_next->props = sc_target_props;`, `  sc_next->prop_len = sc_target_prop_len;`, `  sc_next->prop_cap = sc_target_prop_cap;`, `  scr_arr_release(sc_next);`, `}`, ``);
         return `&${commit}`;
     }
     if (t.kind !== "record")
@@ -1284,12 +1284,7 @@ function emitContainerExpr(emitter, e) {
             e.elems.forEach((el, i) => {
                 const v = emitter.emitExpr(el);
                 if (spreadSet.has(i)) {
-                    const n = `sc_i${emitter.tempCounter++}`;
-                    emitter.line(`for (size_t ${n} = 0, ${n}_len = (size_t)scr_arr_len(${v.name}); ${n} < ${n}_len; ${n}++) {`);
-                    emitter.indent++;
-                    emitter.line(`scr_arr_push_${acc}(${arr.name}, scr_arr_get_${acc}(${v.name}, (double)${n}));`);
-                    emitter.indent--;
-                    emitter.line(`}`);
+                    emitter.line(`scr_arr_push_spread(${arr.name}, ${v.name});`);
                     return;
                 }
                 if (acc === "ref")
@@ -1335,6 +1330,20 @@ function emitContainerExpr(emitter, e) {
             const acc = elemAccess(e.arr.type.elem);
             return emitter.newTemp(e.type, `scr_arr_get_${acc}(${arr.name}, ${idx.name})`);
         }
+        case "arrayHas": {
+            const arr = emitter.emitExpr(e.arr);
+            const idx = emitter.emitExpr(e.index);
+            if (e.arr.type.kind !== "array")
+                throw new InternalCompilerError("emitter bug: arrayHas on non-array");
+            return emitter.newTemp(e.type, `scr_arr_has(${arr.name}, ${idx.name})`);
+        }
+        case "arrayState": {
+            const arr = emitter.emitExpr(e.arr);
+            const idx = emitter.emitExpr(e.index);
+            if (e.arr.type.kind !== "array")
+                throw new InternalCompilerError("emitter bug: arrayState on non-array");
+            return emitter.newTemp(e.type, `scr_arr_state(${arr.name}, ${idx.name})`);
+        }
         case "arrIntrinsic": {
             const r = emitter.emitExpr(e.receiver);
             if (e.receiver.type.kind !== "array")
@@ -1344,6 +1353,10 @@ function emitContainerExpr(emitter, e) {
             switch (method) {
                 case "length":
                     return emitter.newTemp(e.type, `scr_arr_len(${r.name})`);
+                case "nextPresent": {
+                    const start = emitter.emitExpr(e.args[0]);
+                    return emitter.newTemp(e.type, `scr_arr_next_present(${r.name}, ${start.name})`);
+                }
                 case "push": {
                     // Variadic like JS: every argument evaluates first (left to
                     // right — an argument reading the array sees the pre-push
@@ -1363,18 +1376,15 @@ function emitContainerExpr(emitter, e) {
                         : emitter.newTemp(e.type, `scr_arr_len(${r.name})`);
                 }
                 case "pushSpread": {
-                    // `a.push(...src)`: append src's elements in order. The source
-                    // is BORROWED; the count snapshots before the loop so
-                    // `a.push(...a)` duplicates exactly like JS. _get_ref's +1
-                    // moves into _push_ref — RC-balanced. Result: the new length.
+                    // `a.push(...src)`: append src's indexed state in order while
+                    // preserving holes; the runtime snapshots self-spread and
+                    // retains copied refs. Result: the new length.
                     const src = emitter.emitExpr(e.args[0]);
-                    const n = `sc_i${emitter.tempCounter++}`;
-                    emitter.line(`for (size_t ${n} = 0, ${n}_len = (size_t)scr_arr_len(${src.name}); ${n} < ${n}_len; ${n}++) {`);
-                    emitter.indent++;
-                    emitter.line(`scr_arr_push_${acc}(${r.name}, scr_arr_get_${acc}(${src.name}, (double)${n}));`);
-                    emitter.indent--;
-                    emitter.line(`}`);
-                    return emitter.newTemp(e.type, `scr_arr_len(${r.name})`);
+                    return emitter.newTemp(e.type, `scr_arr_push_spread(${r.name}, ${src.name})`);
+                }
+                case "concatSpread": {
+                    const src = emitter.emitExpr(e.args[0]);
+                    return emitter.newTemp(e.type, `scr_arr_concat_copy(${r.name}, ${src.name})`);
                 }
                 case "unshift": {
                     // Like push, every argument evaluates before mutation. Apply
@@ -1396,9 +1406,39 @@ function emitContainerExpr(emitter, e) {
                     return emitter.newTemp(e.type, `scr_arr_unshift_spread(${r.name}, ${src.name})`);
                 }
                 case "pop":
-                    // Ownership of a refcounted element moves OUT of the array to
-                    // this temp (+1 to us, the runtime does not release it).
-                    return emitter.newTemp(e.type, `scr_arr_pop_${acc}(${r.name})`);
+                case "shift": {
+                    // Move the slot once, preserving undefined and holes as values
+                    // while still applying the method's length/index mutation.
+                    if (e.type.kind !== "union")
+                        throw new InternalCompilerError("emitter bug: array removal result is not a union");
+                    const elemT = e.receiver.type.elem;
+                    const def = emitter.unionsById.get(e.type.unionId);
+                    const tag = def ? def.arms.findIndex((arm) => typeEquals(arm, elemT)) : -1;
+                    const undefTag = undefinedArmTag(e.type, emitter.unionsById);
+                    const sameUnion = elemT.kind === "union" && typeEquals(elemT, e.type);
+                    if ((!sameUnion && tag < 0) || undefTag < 0)
+                        throw new InternalCompilerError("emitter bug: array removal union lacks its arms");
+                    const state = `sc_remove_state${emitter.tempCounter++}`;
+                    const slot = `sc_remove_slot${emitter.tempCounter++}`;
+                    emitter.line(`uint64_t ${slot} = 0;`);
+                    emitter.line(`uint8_t ${state} = scr_arr_${method}_state(${r.name}, &${slot});`);
+                    let present;
+                    if (elemT.kind === "f64") {
+                        const number = `sc_remove_number${emitter.tempCounter++}`;
+                        emitter.line(`double ${number}; memcpy(&${number}, &${slot}, sizeof ${number});`);
+                        present = `scr_union_new_f64(${tag}, ${number})`;
+                    }
+                    else if (elemT.kind === "bool") {
+                        present = `scr_union_new_bool(${tag}, ${slot} != 0)`;
+                    }
+                    else {
+                        const ref = `sc_remove_ref${emitter.tempCounter++}`;
+                        emitter.line(`void *${ref}; memcpy(&${ref}, &${slot}, sizeof ${ref});`);
+                        const rc = vAdapters(elemT);
+                        present = sameUnion ? `(ScrUnion *)${ref}` : `scr_union_new_ref(${tag}, ${ref}, &${rc.retain}, &${rc.release}, ${emitter.traceArgC(elemT)})`;
+                    }
+                    return emitter.newTemp(e.type, `${state} == SCR_ARR_VALUE ? ${present} : ${emitter.unitInstanceRef(e.type.unionId, undefTag)}`);
+                }
                 case "indexOf": {
                     // The needle is BORROWED (released with this statement's frame);
                     // the ref variant dispatches on the array's element kind
@@ -1448,6 +1488,12 @@ function emitContainerExpr(emitter, e) {
                     emitter.emitPendingCheck();
                     return out;
                 }
+                case "withUndefined": {
+                    const index = emitter.emitExpr(e.args[0]);
+                    const out = emitter.newTemp(e.type, `scr_arr_with_undefined(${r.name}, ${index.name})`);
+                    emitter.emitPendingCheck();
+                    return out;
+                }
                 case "splice": {
                     // The removal splice: the removed elements come back as a
                     // fresh +1 array, their ownership MOVED out of the receiver
@@ -1457,30 +1503,6 @@ function emitContainerExpr(emitter, e) {
                     const cnt = e.args[1] ? emitter.emitExpr(e.args[1]).name : "INFINITY";
                     return emitter.newTemp(e.type, `scr_arr_splice(${r.name}, ${start.name}, ${cnt})`);
                 }
-                case "shift": {
-                    // JS shift: undefined on an empty array, else the first
-                    // element out (ref ownership moves into the union box) with
-                    // the tail sliding down. Union construction is type-directed
-                    // here, the envGet convention.
-                    if (e.type.kind !== "union")
-                        throw new InternalCompilerError("emitter bug: shift result is not a union");
-                    const elemT = e.receiver.type.elem;
-                    const def = emitter.unionsById.get(e.type.unionId);
-                    const tag = def ? def.arms.findIndex((a) => typeEquals(a, elemT)) : -1;
-                    const undefTag = undefinedArmTag(e.type, emitter.unionsById);
-                    if (tag < 0 || undefTag < 0)
-                        throw new InternalCompilerError("emitter bug: shift union lacks its arms");
-                    const absent = emitter.unitInstanceRef(e.type.unionId, undefTag);
-                    const present = elemT.kind === "f64"
-                        ? `scr_union_new_f64(${tag}, scr_arr_shift_f64(${r.name}))`
-                        : elemT.kind === "bool"
-                            ? `scr_union_new_bool(${tag}, scr_arr_shift_bool(${r.name}))`
-                            : (() => {
-                                const rc = vAdapters(elemT);
-                                return `scr_union_new_ref(${tag}, scr_arr_shift_ref(${r.name}), &${rc.retain}, &${rc.release}, ${emitter.traceArgC(elemT)})`;
-                            })();
-                    return emitter.newTemp(e.type, `scr_arr_len(${r.name}) ? ${present} : ${absent}`);
-                }
                 default: {
                     const _exhaustive = method;
                     void _exhaustive;
@@ -7832,6 +7854,8 @@ export function emitExpr(emitter, e) {
         case "arrayLit":
         case "arrayNewLen":
         case "arrayGet":
+        case "arrayHas":
+        case "arrayState":
         case "arrIntrinsic":
         case "bytesNew":
         case "bytesIntrinsic":