@scriptc/compiler 0.0.33 → 0.0.35

package/dist/frontend/lowering/lower-containers.js

@@ -3,7 +3,7 @@
  * methods with Node-exact forEach desugaring, and the string and regex
  * method surfaces. */
 import * as ts from "../ts7/adapter.js";
-import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, funcOf, isRefCounted, isSupportedIndexValue, isUnitType, typeEquals } from "../../ir/nodes.js";
+import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, funcOf, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isUnitType, typeEquals } from "../../ir/nodes.js";
 import { ARRAY_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS, STR_METHODS } from "./surfaces.js";
 import { droppableStatic, isRequireMainFilename, lowerDynObjectLiteral, probeLower, pureReemittable } from "./lower-exprs.js";
 import { forOfVarTarget, lowerDestructuringAssign } from "./lower-stmts.js";
@@ -91,6 +91,18 @@ function lowerSplitLimitArg(L, node, loc) {
     const defaultValue = { kind: "numLit", value: 4294967295, type: F64, loc };
     return node ? lowerOptionalDefaultArg(L, node, F64, defaultValue) : defaultValue;
 }
+/** Callback-driven array producers bypass mapType's ordinary T[] mapping:
+ * the callback is lowered first, then the helper's result array is built
+ * directly from its IR return type. Fence element kinds ScrArr cannot hold
+ * before constructing that array type. */
+function fenceProducedArrayElem(L, node, producer, elem) {
+    if (elem.kind === "dyn") {
+        L.unsupported("SC1090", node, `${producer} with a callback returning 'unknown'-typed values (the result array has no static element type — annotate the callback's return)`);
+    }
+    if (!isSupportedArrayElem(elem)) {
+        L.unsupported("SC1090", node, `${producer} with a callback returning '${L.fmt(elem)}' values (arrays of this element kind have no representation — store the values individually)`);
+    }
+}
 /** Ambient array method calls. `push`/`unshift`/`pop`/`reverse`/
  * `indexOf`/`includes`/`join`
    * lower to arrIntrinsic; the HOF family — `map`/`filter`/`forEach`/
@@ -566,28 +578,8 @@ export function lowerArrayHofCall(L, call, access, method, elem) {
         // story yet).
         L.badType(call, L.typeOf(call));
     }
-    if (method === "map" &&
-        (fnRet.kind === "map" || fnRet.kind === "set" || fnRet.kind === "url" ||
-            fnRet.kind === "searchParams" || fnRet.kind === "generator" || fnRet.kind === "caught" ||
-            fnRet.kind === "stats" || fnRet.kind === "fileHandle" || fnRet.kind === "spawnRes" || fnRet.kind === "netSocket" ||
-            fnRet.kind === "dgramSocket" || fnRet.kind === "testCtx" || fnRet.kind === "httpReq" ||
-            fnRet.kind === "httpRes" || fnRet.kind === "httpClientReq" || fnRet.kind === "secureCtx" ||
-            fnRet.kind === "fsWatcher" || fnRet.kind === "childStream" || fnRet.kind === "procStream" ||
-            isUnitType(fnRet))) {
-        // The result would be an array of an element kind ScrArr has no
-        // home for (mapTypeOf's own array exclusions) — the callback return
-        // type bypasses that gate, so it is enforced here: a named fence,
-        // never a mistyped array into the backends.
-        L.unsupported("SC1090", call, `'.map()' with a callback returning '${L.fmt(fnRet)}' values (arrays of this element kind have no representation — store the values individually)`);
-    }
-    if (method === "map" && fnRet.kind === "dyn") {
-        // A checked-dynamic callback return would make the result a
-        // dyn-element STATIC array, which has no backend representation
-        // (dynFallbackType's rule: an unmappable element makes the WHOLE
-        // value dyn — but map's fresh array is built here, not by a
-        // declaration, so the honest answer is the fence).
-        L.unsupported("SC1090", call, "'.map()' with a callback returning 'unknown'-typed values (the result array has no static element type — annotate the callback's return)");
-    }
+    if (method === "map")
+        fenceProducedArrayElem(L, call, "'.map()'", fnRet);
     // JS applies ToBoolean to whatever the predicate answers, so a non-bool
     // result is not an error — the filter loop wraps the call in the same
     // toBool an `if` statement would apply. The island/dyn shapes, whose
@@ -753,6 +745,7 @@ export function lowerTupleReadMethodCall(L, call, access) {
     const fnRet = fnArg.type.ret;
     if (fnRet.kind === "void" || fnRet.kind === "func")
         L.badType(call, L.typeOf(call));
+    fenceProducedArrayElem(L, call, "'.map()'", fnRet);
     const helper = arrayHofHelper(L, "map", snapshotElem, fnRet, arity, loc);
     return { kind: "call", callee: helper, args: [snapshot, fnArg], type: arrayOf(fnRet), loc };
 }
@@ -1270,6 +1263,7 @@ export function lowerArrayFlatMapCall(L, call, access, elem) {
         // No flatten happens: exactly map's loop, map's helper.
         if (fnRet.kind === "void" || fnRet.kind === "func")
             L.badType(call, L.typeOf(call));
+        fenceProducedArrayElem(L, call, "'.flatMap()'", fnRet);
         const helper = arrayHofHelper(L, "map", elem, fnRet, arity, loc);
         return { kind: "call", callee: helper, args: [receiver, fnArg], type: arrayOf(fnRet), loc };
     }
@@ -2356,6 +2350,7 @@ export function lowerArrayFromCall(L, call, access) {
     const fnRet = fnT.ret;
     if (fnRet.kind === "void" || fnRet.kind === "func")
         L.badType(call, L.typeOf(call));
+    fenceProducedArrayElem(L, call, "'Array.from({ length }, mapper)'", fnRet);
     const arity = fnT.params.length;
     const key = `fromLen:${typeKey(fnRet)}:${arity}`;
     let helper = L.arrHofHelpers.get(key);
@@ -5854,6 +5849,7 @@ export function objectIterOverIndexShape(L, node, member, argIr, shape, receiver
         const body = [
             { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: resultT, loc }, loc },
         ];
+        const fieldStmts = new Map();
         // Declared fields, in declaration order. Undefined-valued fields
         // skip at runtime (the unset-optional convention); values surface
         // into the element type or the site fences with the field named.
@@ -5921,7 +5917,7 @@ export function objectIterOverIndexShape(L, node, member, argIr, shape, receiver
                             loc,
                         };
             }
-            body.push(utag >= 0 && f.type.kind === "union"
+            const fieldStmt = utag >= 0 && f.type.kind === "union"
                 ? {
                     kind: "if",
                     cond: { kind: "unionIsTag", unionId: f.type.unionId, tag: utag, negated: true, value: raw, type: BOOL, loc },
@@ -5929,7 +5925,9 @@ export function objectIterOverIndexShape(L, node, member, argIr, shape, receiver
                     else_: null,
                     loc,
                 }
-                : push(pushed));
+                : push(pushed);
+            fieldStmts.set(f.name, fieldStmt);
+            body.push(fieldStmt);
         }
         // The overflow walk: a fresh key snapshot in JS own-key order, each
         // value read back through the overflow-only keyed read (declared
@@ -5976,8 +5974,9 @@ export function objectIterOverIndexShape(L, node, member, argIr, shape, receiver
             ],
             loc,
         }, { kind: "return", value: outRef, loc });
+        const suffix = body.slice(1 + fieldStmts.size);
         L.arrHofHelpers.set(key, helper);
-        L.liftedFns.push({
+        const fn = {
             name: helper,
             params: [{ localId: "r.0", name: "r", type: argIr }],
             returnType: resultT,
@@ -5990,7 +5989,16 @@ export function objectIterOverIndexShape(L, node, member, argIr, shape, receiver
             ],
             body,
             loc,
+        };
+        L.shapeOrderHelperFinalizers.push(() => {
+            const current = L.shapes.get(argIr.shapeId) ?? shape;
+            const currentOrder = current.declaredOrder ?? current.fields.map((f) => f.name);
+            fn.body = [body[0], ...currentOrder.flatMap((name) => {
+                    const stmt = fieldStmts.get(name);
+                    return stmt ? [stmt] : [];
+                }), ...suffix];
         });
+        L.liftedFns.push(fn);
     }
     return { kind: "call", callee: helper, args: [receiver], type: resultT, loc };
 }
@@ -6356,6 +6364,7 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
             loc,
         },
     ];
+    const fieldStmts = new Map();
     // Source declared fields in declaration order, skipping unset
     // optionals (stance 37) and the direct-initialized (consumed) names.
     for (const ff of orderedFields) {
@@ -6374,7 +6383,7 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
             ...(to.fields.some((f) => f.name === ff.name) ? {} : { overflowOnly: true }),
             loc,
         };
-        body.push(utag >= 0 && ff.type.kind === "union"
+        const fieldStmt = utag >= 0 && ff.type.kind === "union"
             ? {
                 kind: "if",
                 cond: { kind: "unionIsTag", unionId: ff.type.unionId, tag: utag, negated: true, value: raw, type: BOOL, loc },
@@ -6382,7 +6391,9 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
                 else_: null,
                 loc,
             }
-            : write);
+            : write;
+        fieldStmts.set(ff.name, fieldStmt);
+        body.push(fieldStmt);
     }
     // The source overflow, in JS own-key order (only index-signature
     // sources carry one).
@@ -6421,7 +6432,8 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
         });
     }
     body.push({ kind: "return", value: outRef, loc });
-    L.liftedFns.push({
+    const suffix = body.slice(1 + fieldStmts.size);
+    const fn = {
         name,
         params: [{ localId: "s.0", name: "s", type: fromT }],
         returnType: toT,
@@ -6438,7 +6450,16 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
         ],
         body,
         loc,
+    };
+    L.shapeOrderHelperFinalizers.push(() => {
+        const current = L.shapes.get(fromId) ?? from;
+        const currentOrder = current.declaredOrder ?? current.fields.map((f) => f.name);
+        fn.body = [body[0], ...currentOrder.flatMap((field) => {
+                const stmt = fieldStmts.get(field);
+                return stmt ? [stmt] : [];
+            }), ...suffix];
     });
+    L.liftedFns.push(fn);
     return name;
 }
 /** `Object.assign(target, ...sources)` into an INDEX-SIGNATURE record:
@@ -6531,6 +6552,7 @@ export function lowerObjectAssignIndexShape(L, call) {
         const sRef = ref("s.0", fromT);
         const intoSlot = (v, lift) => lift === "dyn" ? { kind: "dynFrom", value: v, type: DYN, loc } : L.applyWidthLift(lift, v, tIv, loc);
         const body = [];
+        const fieldStmts = new Map();
         for (const ff of plan.fields) {
             const raw = { kind: "recordGet", obj: sRef, shapeId: plan.fromId, field: ff.name, type: ff.type, loc };
             const utag = ff.type.kind === "union" ? L.armTag(ff.type.unionId, UNDEFINED_T) : -1;
@@ -6542,7 +6564,7 @@ export function lowerObjectAssignIndexShape(L, call) {
                 value: intoSlot(raw, ff.lift),
                 loc,
             };
-            body.push(utag >= 0 && ff.type.kind === "union"
+            const fieldStmt = utag >= 0 && ff.type.kind === "union"
                 ? {
                     kind: "if",
                     cond: { kind: "unionIsTag", unionId: ff.type.unionId, tag: utag, negated: true, value: raw, type: BOOL, loc },
@@ -6550,7 +6572,9 @@ export function lowerObjectAssignIndexShape(L, call) {
                     else_: null,
                     loc,
                 }
-                : write);
+                : write;
+            fieldStmts.set(ff.name, fieldStmt);
+            body.push(fieldStmt);
         }
         const ksT = arrayOf(STRING);
         const fromShape = L.shapes.get(plan.fromId);
@@ -6588,7 +6612,8 @@ export function lowerObjectAssignIndexShape(L, call) {
             });
         }
         body.push({ kind: "return", value: tRef, loc });
-        L.liftedFns.push({
+        const suffix = body.slice(fieldStmts.size);
+        const fn = {
             name,
             params: [
                 { localId: "t.0", name: "t", type: toT },
@@ -6608,7 +6633,16 @@ export function lowerObjectAssignIndexShape(L, call) {
             ],
             body,
             loc,
+        };
+        L.shapeOrderHelperFinalizers.push(() => {
+            const current = L.shapes.get(plan.fromId) ?? fromShape;
+            const currentOrder = current.declaredOrder ?? current.fields.map((f) => f.name);
+            fn.body = [...currentOrder.flatMap((field) => {
+                    const stmt = fieldStmts.get(field);
+                    return stmt ? [stmt] : [];
+                }), ...suffix];
         });
+        L.liftedFns.push(fn);
         return name;
     };
     let acc = L.lowerExprExpecting(call.arguments[0], targetIr);