@scriptc/compiler 0.2.7 → 0.2.8

package/dist/frontend/lowering/containers/array-callbacks.js

@@ -33,7 +33,8 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
         ts.isIdentifier(argNode) &&
         argNode.text === "Boolean" &&
         lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(argNode) ?? undefined);
-    const valueT = arrayValueType(lowerer, elem);
+    const present = !booleanFilter && presentElements(lowerer, call, elem);
+    const valueT = callbackValueType(lowerer, elem, present);
     if (booleanFilter) {
         if (valueT.kind === "union")
             lowerer.requireTruthyUnion(valueT.unionId, argNode);
@@ -74,10 +75,10 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
         ? filterResultElem(lowerer, call, argNode, elem, valueT, booleanFilter)
         : callbackArrayElement(lowerer, call, fnRet);
     // A filter that re-tags its elements keeps the single union-typed visit.
-    const fast = booleanFilter || (method === "filter" && !typeEquals(outElem, elem))
+    const fast = present || booleanFilter || (method === "filter" && !typeEquals(outElem, elem))
         ? null
         : lowerFastCallback(lowerer, argNode, [valueT], 0, elem, arrayOf(elem), callback);
-    const helper = arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null);
+    const helper = arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present);
     const resultType = method === "map" || method === "filter" ? arrayOf(outElem) : VOID;
     return {
         kind: "call",
@@ -383,18 +384,39 @@ function withFastCallback(fn, fastT, elem) {
 function callbackSite(fnArg) {
     return fnArg.kind === "closure" ? `@${fnArg.fnName}` : "";
 }
+/** The optional-read analysis proved this call's receiver never holds an
+ * explicit undefined (or, for the find family, a hole): its callback takes
+ * the element type itself, read without a state test. A missing value the
+ * proof excluded would make the element read trap instead of producing a
+ * wrong value. */
+function presentElements(lowerer, call, elem) {
+    return (lowerer.presentElementCalls.has(call) &&
+        elem.kind !== "dyn" &&
+        elem.kind !== "jsval" &&
+        elem.kind !== "void" &&
+        !isUnitType(elem));
+}
+/** The value a helper passes its callback for one visited index. */
+function callbackValueType(lowerer, elem, present) {
+    return present ? elem : arrayValueType(lowerer, elem);
+}
+function callbackValueRead(lowerer, arr, index, elem, present, loc) {
+    return present
+        ? { kind: "arrayGet", arr, index, type: elem, loc }
+        : arrayValueRead(lowerer, arr, index, elem, loc);
+}
 /** Interned synthetic loop function for one (method, elem, fnRet, arity)
  * combo. Named `%arr.<method>.<n>` ('%' keeps it out of the user
  * namespace); rides `liftedFns` into the module like a lifted lambda (it
  * is a plain function — no captures). */
-function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRet, site = "", fastT = null) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}`;
+function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRet, site = "", fastT = null, present = false) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
     const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, name);
-    const fn = buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT);
+    const fn = buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT, present);
     lowerer.liftedFns.push(fastT ? withFastCallback(fn, fastT, elem) : fn);
     return name;
 }
@@ -553,14 +575,14 @@ function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arit
  * `arity` is the callback's declared parameter count (1–3): the loop
  * passes the index and the receiver itself after the element when the
  * callback names them, exactly the arguments JS supplies. */
-function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT = null) {
+function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT = null, present = false) {
     const arrT = arrayOf(elem);
-    const valueT = arrayValueType(lowerer, elem);
-    const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
+    const valueT = callbackValueType(lowerer, elem, present);
+    const fnT = funcOf([valueT, F64, arrT].slice(0, arity), fnRet);
     const locals = arrayCallbackLocals(arrT, fnT);
     const params = arrayCallbackParams(arrT, fnT);
     const callF = (arg) => callArrayCallback(arrT, fnT, fnRet, arity, arg, loc);
-    const getElem = arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc);
+    const getElem = callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc);
     const hasElem = {
         kind: "arrayHas",
         arr: varRef("a.0", arrT, loc),
@@ -798,7 +820,12 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
     const argNode = call.arguments[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
-    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], arrT, bindUntyped);
+    // find's result must be reachable from the element itself; a predicate
+    // that narrows to another layout keeps the optional element visit.
+    const present = presentElements(lowerer, call, elem) &&
+        ((method !== "find" && method !== "findLast") ||
+            (!bindUntyped && lowerer.coercibleValue(elem, lowerer.irTypeOf(call))));
+    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [callbackValueType(lowerer, elem, present)], arrT, bindUntyped);
     // JS takes the ToBoolean of the predicate's result — allowed wherever
     // that ToBoolean has a static answer (bool passes through; f64/string
     // by value; a truthy-answerable union by its arm — the
@@ -818,11 +845,13 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
         method === "every" ||
         method === "findIndex" ||
         method === "findLastIndex") {
-        const fast = lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, { fnArg, arity }, bindUntyped);
+        const fast = present
+            ? null
+            : lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, { fnArg, arity }, bindUntyped);
         const fastT = fast?.type ?? null;
         const helper = method === "findIndex" || method === "findLastIndex"
-            ? findIndexHelper(lowerer, elem, fnRet, arity, last, loc, callbackSite(fast ?? fnArg), fastT)
-            : someEveryHelper(lowerer, method, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fastT);
+            ? findIndexHelper(lowerer, elem, fnRet, arity, last, loc, callbackSite(fast ?? fnArg), fastT, present)
+            : someEveryHelper(lowerer, method, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fastT, present);
         return {
             kind: "call",
             callee: helper,
@@ -836,7 +865,7 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
     // element inherits that earlier refinement. Otherwise only an inline,
     // inferred predicate proves a new narrowing; explicit assertions keep
     // the same refusal boundary as filter.
-    const valueT = arrayValueType(lowerer, elem);
+    const valueT = callbackValueType(lowerer, elem, present);
     const checkerReceiver = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
     const checkerResult = lowerer.irTypeOf(call);
     const unchangedElement = checkerReceiver?.kind === "array" &&
@@ -867,7 +896,7 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
             !(present.kind === "object" && canAssertClassValue(lowerer, valueT, present)))
             lowerer.unsupported("SC1090", call, `'.${method}' narrowing to an incompatible result layout`);
     }
-    const helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, callbackSite(fnArg));
+    const helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, callbackSite(fnArg), present);
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultT, loc };
 }
 /** ToBoolean of a predicate result inside a synthesized HOF helper — the
@@ -886,23 +915,23 @@ function predicateToBoolean(e) {
  *   for (i = 0; i < n; i++) { v = a[i]; if (f(v)) return <v as result arm>; }
  *   return <undefined arm>;
  */
-function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, site = "") {
+function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, site = "", present = false) {
     const method = last ? "findLast" : "find";
-    const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}`;
+    const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}${present ? ":present" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
     const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
-    const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
-    const valueT = arrayValueType(lowerer, elem);
+    const valueT = callbackValueType(lowerer, elem, present);
+    const fnT = funcOf([valueT, F64, arrT].slice(0, arity), fnRet);
     const v = varRef("v.0", valueT, loc);
-    const present = lowerer.stripUndefinedArm(resultT);
+    const presentArm = lowerer.stripUndefinedArm(resultT);
     // A successful inferred class predicate may select a descendant of a
     // stored base arm. Keep the value read before the callback mutated the array.
-    const classView = retag === null && !lowerer.coercibleValue(valueT, resultT) && present.kind === "object"
-        ? checkedClassAssertion(lowerer, v, present, loc)
+    const classView = retag === null && !lowerer.coercibleValue(valueT, resultT) && presentArm.kind === "object"
+        ? checkedClassAssertion(lowerer, v, presentArm, loc)
         : null;
     const found = retag === null
         ? lowerer.coerceToExpected(classView ?? v, resultT)
@@ -919,7 +948,7 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
         {
             kind: "varDecl",
             localId: "v.0",
-            init: arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc),
+            init: callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc),
             loc,
         },
         {
@@ -957,20 +986,20 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
  *
  *   n = a.length; for (...) if (f(a[i], i, a)) return i;  return -1;
  */
-function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fastT = null) {
+function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fastT = null, present = false) {
     const method = last ? "findLastIndex" : "findIndex";
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}`;
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
     const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
-    const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
+    const fnT = funcOf([callbackValueType(lowerer, elem, present), F64, arrT].slice(0, arity), fnRet);
     const visit = [
         {
             kind: "if",
-            cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc), loc)),
+            cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc), loc)),
             then: [{ kind: "return", value: varRef("i.0", F64, loc), loc }],
             else_: null,
             loc,
@@ -999,16 +1028,16 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fast
  *   some:  n = a.length; for (...) if (f(a[i])) return true;  return false;
  *   every: n = a.length; for (...) if (!f(a[i])) return false; return true;
  */
-function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fastT = null) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}`;
+function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fastT = null, present = false) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
     const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
-    const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
-    const callF = predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc), loc));
+    const fnT = funcOf([callbackValueType(lowerer, elem, present), F64, arrT].slice(0, arity), fnRet);
+    const callF = predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc), loc));
     const body = [
         arrayLengthDeclaration(arrT, loc),
         countedFor(loc, varRef("n.0", F64, loc), () => [
@@ -1055,7 +1084,8 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
     const argNode = call.arguments[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
-    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], arrT);
+    const present = presentElements(lowerer, call, elem);
+    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [callbackValueType(lowerer, elem, present)], arrT);
     const fnRet = fnArg.type.ret;
     if (fnRet.kind === "dyn" ||
         fnRet.kind === "jsval" ||
@@ -1083,8 +1113,13 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             lowerer.badType(call, lowerer.typeOf(call));
         requireProducedArrayElement(lowerer, call, "'.flatMap()'", fnRet);
         const outElem = callbackArrayElement(lowerer, call, fnRet);
-        const fast = lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, { fnArg, arity });
-        const helper = arrayHofHelper(lowerer, "flatMap", elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null);
+        const fast = present
+            ? null
+            : lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, {
+                fnArg,
+                arity,
+            });
+        const helper = arrayHofHelper(lowerer, "flatMap", elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present);
         return {
             kind: "call",
             callee: helper,
@@ -1093,11 +1128,13 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             loc,
         };
     }
-    const fast = lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, {
-        fnArg,
-        arity,
-    });
-    const helper = flatMapHelper(lowerer, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fast?.type ?? null);
+    const fast = present
+        ? null
+        : lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, {
+            fnArg,
+            arity,
+        });
+    const helper = flatMapHelper(lowerer, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fast?.type ?? null, present);
     return {
         kind: "call",
         callee: helper,
@@ -1115,8 +1152,8 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
  *   }
  *   return out;
  */
-function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null) {
-    const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}`;
+function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null, present = false) {
+    const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1124,7 +1161,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
     const inner = fnRet.elem;
-    const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
+    const fnT = funcOf([callbackValueType(lowerer, elem, present), F64, arrT].slice(0, arity), fnRet);
     const innerLoop = {
         kind: "for",
         init: { kind: "varDecl", localId: "j.0", init: numLit(0, loc), loc },
@@ -1191,7 +1228,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null
                     {
                         kind: "varDecl",
                         localId: "r.0",
-                        init: callArrayCallback(arrT, fnT, fnRet, arity, arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc), loc),
+                        init: callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc), loc),
                         loc,
                     },
                     {