@scriptc/compiler 0.2.5 → 0.2.7

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

@@ -2,6 +2,7 @@ import { dynUndefinedExpr, numLit, varRef } from "../../ir/build.js";
 import { lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { importMetaBindingSource } from "./import-meta.js";
 import { iteratorCanStep, iteratorValue } from "./iterator-consumption.js";
+import { isPrivateSplitConsumer } from "./split-consumers.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Statement lowering: the statement dispatch (lowerStmt), variable
  * declarations including destructuring patterns, scoped blocks, control
@@ -9,7 +10,7 @@ import { InternalCompilerError } from "../../errors.js";
  * explicit resource management, and blocked-binding poisoning. */
 import * as ts from "../ts7/adapter.js";
 import { bindingSource } from "../binding-source.js";
-import { arrayValueRead, arrayValueStore, arrayValueType, unionArrayValueRead, } from "./array-values.js";
+import { arrayValueRead, arrayValueStore, arrayValueType, unionArrayValueRead, lowerSafeIndexRead, } from "./array-values.js";
 import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement, } from "./lower-generators.js";
 import { lowerForAwaitBuiltin } from "./lower-async-iteration.js";
 import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
@@ -22,7 +23,6 @@ import { isProvenanceSourceFile } from "../provenance-registry.js";
 import { ambientUndefVarRootOf, lowerImportEquals, nsUndefRead, nsWritableTarget, trapDeclRootOf, } from "./lower-namespaces.js";
 import { expandoWritableTarget, lowerExpandoAssignStmt } from "./lower-expando.js";
 import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, } from "./containers/for-of.js";
-import { lowerSafeIndexRead } from "./containers/array-methods.js";
 import { objectIterOverIndexShape } from "./containers/indexed-objects.js";
 import { strCharsCall } from "./containers/array-construction.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, } from "./generic-functions.js";
@@ -36,7 +36,7 @@ import { classStaticDataFor } from "./class-static-data.js";
 import { objectFactorySignature } from "./object-factory-new.js";
 import { isClassCallback, lowerClassCallbackAssign } from "./class-callbacks.js";
 import { classForInHasKey, classPropertiesHelper } from "./class-dynamic-dispatch.js";
-import { genericIfaceBindingKeepsClass, staticFieldWriteTarget } from "./lower-classes.js";
+import { genericIfaceBindingKeepsClass } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment, } from "./lower-server.js";
 import { lowerUrlAssignment } from "./builtins/url.js";
@@ -44,7 +44,7 @@ import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructu
 import { lowerNodeModuleCall } from "./builtins/module-resolution.js";
 import { registerBuiltinCallableAlias } from "./builtins/callable-aliases.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompound, lowerIncDec, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed, } from "./lower-exprs.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompound, lowerIncDec, lowerIncDecTarget, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed, } from "./lower-exprs.js";
 import { globalSymbolKey } from "./expressions/global-symbols.js";
 import { lowerShortCircuitAssignment } from "./expressions/nullish-assignment.js";
 import { lowerEnvironmentKey, lowerNativeFunctionAssignment } from "./lower-exprs.js";
@@ -3041,14 +3041,14 @@ function objectRestValue(lowerer, el, srcRef, srcType, shape) {
             kind: "recordLit",
             fields: rem.map((f) => ({
                 name: f.name,
-                value: {
+                value: lowerer.presenceKeepingCopy(srcRef(), srcType.shapeId, f.name, {
                     kind: "recordGet",
                     obj: srcRef(),
                     shapeId: srcType.shapeId,
                     field: f.name,
                     type: f.type,
                     loc,
-                },
+                }, loc),
             })),
             type: {
                 kind: "record",
@@ -3082,7 +3082,10 @@ function objectRestValue(lowerer, el, srcRef, srcType, shape) {
             type: srcField.type,
             loc,
         };
-        return { name: f.name, value: lowerer.coerceInto(el, read, f.type) };
+        return {
+            name: f.name,
+            value: lowerer.presenceKeepingCopy(srcRef(), srcType.shapeId, srcField.name, lowerer.coerceInto(el, read, f.type), loc),
+        };
     });
     return { kind: "recordLit", fields, type: restT, loc };
 }
@@ -3613,10 +3616,14 @@ export function bindPatternTarget(lowerer, name, value, isLet, out, allowDynObje
         // through later locals, templates, operators, and narrowing instead
         // of being extracted with a checked arm read.
         let runtimeOptional = false;
+        // The optional-read pre-pass may already have widened the binding to
+        // that union; its reads still need the runtime-optional treatment.
         if (!dynStays &&
             value.type.kind === "union" &&
             lowerer.armTag(value.type.unionId, UNDEFINED_T) >= 0 &&
-            typeEquals(lowerer.stripUndefinedArm(value.type), type)) {
+            (typeEquals(lowerer.stripUndefinedArm(value.type), type) ||
+                (typeEquals(value.type, type) &&
+                    typeEquals(lowerer.stripUndefinedArm(value.type), lowerer.irTypeOf(name))))) {
             type = value.type;
             runtimeOptional = true;
         }
@@ -4019,10 +4026,13 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             g.type = DYN;
         g.type = inferredOptionalRecordType(lowerer, decl, g.type, raw.type);
         const arithmetic = raw.type.kind === "union" ? lowerer.unions.get(raw.type.unionId)?.arms : undefined;
-        if (g.type.kind === "string" &&
-            arithmetic?.length === 2 &&
-            arithmetic.some((a) => a.kind === "f64") &&
-            arithmetic.some((a) => a.kind === "string")) {
+        if (arithmetic?.length === 2 &&
+            arithmetic.every((a) => a.kind === "f64" || a.kind === "string" || a.kind === "bool") &&
+            (lowerer.runtimeOptionalArithmeticTypes.has(decl.initializer) ||
+                lowerer.runtimeOptionalBindingType(decl.name)?.kind === "union" ||
+                (g.type.kind === "string" &&
+                    arithmetic.some((a) => a.kind === "f64") &&
+                    arithmetic.some((a) => a.kind === "string")))) {
             g.type = raw.type;
             lowerer.runtimeOptionalArithmeticGlobals.add(g);
         }
@@ -4393,9 +4403,13 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             arms.some((a) => a.kind === "f64") &&
             arms.some((a) => a.kind === "string"));
     };
-    const runtimeStringArithmetic = settledType.kind === "string" &&
-        ((arithmeticType && typeEquals(arithmeticType, init.type)) ||
-            isStringArithmeticUnion(init.type));
+    const runtimeStringArithmetic = (arithmeticType !== undefined && typeEquals(arithmeticType, init.type)) ||
+        (settledType.kind === "string" && isStringArithmeticUnion(init.type)) ||
+        (init.type.kind === "union" &&
+            typeEquals(lowerer.runtimeOptionalBindingType(decl.name, settledType), init.type) &&
+            lowerer.unions
+                .get(init.type.unionId)
+                ?.arms.every((a) => a.kind === "f64" || a.kind === "string" || a.kind === "bool") === true);
     if (runtimeStringArithmetic) {
         settledType = init.type;
     }
@@ -4499,12 +4513,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             settledType = init.type;
         }
     }
-    // `const r: Repo = new MemRepo()` over an all-generic-method
-    // interface: the binding keeps the initializer's CLASS representation
-    // (the record shape maps empty and the width copy would drop the
-    // class the generic-method calls monomorphize against) — see
-    // genericIfaceBindingKeepsClass.
-    if (settledType.kind === "record" &&
+    // An exact class behind a generic interface keeps its native
+    // representation so generic calls can specialize against its body.
+    if ((settledType.kind === "record" || settledType.kind === "dyn") &&
         init.type.kind === "object" &&
         genericIfaceBindingKeepsClass(lowerer, decl, settledType)) {
         settledType = init.type;
@@ -4530,7 +4541,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // subtyping (`const p: {a: number} = wider;`) is rejected, not coerced.
     init = lowerer.coerceInto(decl.initializer, init, settledType);
     const local = lowerer.declareLocal(decl.name, decl.name.text, settledType, isLet);
-    if (runtimeStringArithmetic && isStringArithmeticUnion(init.type)) {
+    if (runtimeStringArithmetic && init.type.kind === "union") {
         lowerer.runtimeOptionalArithmeticLocals.add(lowerer.runtimeOptionalRootOf(local));
     }
     if (runtimeOptional) {
@@ -5018,8 +5029,9 @@ function isStrictDelete(node) {
 }
 /** Statement-position `delete`: process.env keys → process.envUnset
  * (unsetenv), pure `Record<string, T>` keys → recordKeyDelete (the
- * overflow Map delete), declared OPTIONAL fields → the undefined-arm
- * write (absence IS the undefined arm; divergence 60). Everything else
+ * overflow Map delete), declared OPTIONAL fields → the field's ABSENT
+ * state (the slot reads undefined and no longer counts as an own
+ * property). Everything else
  * fences with the honest reason — a required field is a struct slot no
  * runtime can remove. */
 function lowerDeleteStatement(lowerer, expr) {
@@ -5135,14 +5147,13 @@ function lowerDeleteStatement(lowerer, expr) {
         if (shape?.indexValue && shape.fields.length === 0 && !shape.tuple) {
             return { kind: "recordKeyDelete", obj, shapeId: obj.type.shapeId, key: lowerKey(), loc };
         }
-        // `delete r.f` of a declared OPTIONAL field (undefined-armed slot) is
-        // the undefined-arm write: a monomorphic shape cannot remove its
-        // slot, and absence IS the undefined arm (divergences 37/56), so the
-        // observable results — `in` answers false, Object.keys skips it,
-        // JSON.stringify drops it — match Node's post-delete answers exactly
-        // (divergence 60 documents the delete/`= undefined` collapse).
-        // Constant keys only (dot access or a literal bracket); required
-        // fields keep the honest fence below.
+        // `delete r.f` of a declared OPTIONAL field (undefined-armed slot)
+        // writes the field's ABSENT state: a monomorphic shape cannot remove
+        // its slot, but the slot remembers that no property exists, so `in`
+        // answers false, Object.keys skips it, and JSON.stringify drops it,
+        // while a later write makes it present again. Constant keys only
+        // (dot access or a literal bracket); required fields keep the honest
+        // fence below.
         const fieldName = ts.isPropertyAccessExpression(target)
             ? target.name.text
             : ts.isStringLiteral(target.argumentExpression)
@@ -5152,7 +5163,7 @@ function lowerDeleteStatement(lowerer, expr) {
             ? shape?.fields.find((f) => f.name === fieldName)
             : undefined;
         if (field) {
-            const absent = lowerer.wrappedUndefined(field.type, loc);
+            const absent = lowerer.absentFieldValue(field.type, loc);
             if (absent) {
                 return {
                     kind: "recordSet",
@@ -5966,7 +5977,7 @@ export function lowerExprStatement(lowerer, expr) {
                 }
                 const unionWrite = lowerUnionFieldWrite(lowerer, expr.left, expr.right);
                 if (unionWrite)
-                    return unionWrite;
+                    return { kind: "exprStmt", expr: unionWrite, loc: locOf(expr) };
                 const target = lowerer.fieldTarget(expr.left);
                 if (target) {
                     const value = lowerer.lowerExprExpecting(expr.right, target.fieldType);
@@ -6164,27 +6175,7 @@ export function lowerExprStatement(lowerer, expr) {
             };
         }
         // Statement position only: pre/post distinction is unobservable, so
-        // both desugar to `x = x ± 1`.
-        if (ts.isPropertyAccessExpression(expr.operand) ||
-            (ts.isElementAccessExpression(expr.operand) && symbolFieldInfo(lowerer, expr.operand))) {
-            // `N.x++` — the namespace-qualified spelling of a module-global
-            // increment (the member's global IS the variable); expando
-            // function members (`foo.count++`) are module globals too.
-            if (ts.isPropertyAccessExpression(expr.operand) && !expr.operand.questionDotToken) {
-                const staticTarget = staticFieldWriteTarget(lowerer, expr.operand);
-                if (staticTarget)
-                    return lowerIncDecToTarget(lowerer, expr, staticTarget);
-                const exT = expandoWritableTarget(lowerer, expr.operand);
-                if (exT)
-                    return lowerIncDecToTarget(lowerer, expr, exT);
-                const nsT = nsWritableTarget(lowerer, expr.operand);
-                if (nsT)
-                    return lowerIncDecToTarget(lowerer, expr, nsT);
-            }
-            // `obj.f++` desugars through the compound-field path (`obj.f += 1`);
-            // `this[kLimit]++` is the same desugar over the symbol-keyed slot.
-            return lowerer.lowerFieldCompound(expr.operand, expr.operator === ts.SyntaxKind.PlusPlusToken ? "+" : "-", null, locOf(expr));
-        }
+        // numeric bindings retain the simple `x = x ± 1` loop form.
         if (!ts.isIdentifier(expr.operand)) {
             lowerer.unsupported("SC1090", expr.operand, "increment/decrement of non-variables");
         }
@@ -6271,22 +6262,17 @@ function lowerIncDecToTarget(lowerer, expr, target) {
     const loc = locOf(expr);
     const op = expr.operator === ts.SyntaxKind.PlusPlusToken ? "+" : "-";
     const readTarget = { kind: "varRef", localId: target.id, type: target.type, loc };
-    // JS any-origin targets: check the read to number, convert the
-    // result back into the dyn slot (the compound-assign stance).
-    const dynTarget = target.type.kind === "dyn" && isJsSourceFile(expr.getSourceFile());
-    if (target.type.kind !== "f64" && !dynTarget) {
-        lowerer.unsupported("SC1090", expr.operand, "increment/decrement of non-number targets");
-    }
+    if (target.type.kind !== "f64")
+        return { kind: "exprStmt", expr: lowerIncDecTarget(lowerer, expr, target, false), loc };
     const computed = {
         kind: "bin",
         op,
-        left: dynTarget ? { kind: "dynCheck", value: readTarget, type: F64, loc } : readTarget,
+        left: readTarget,
         right: { kind: "numLit", value: 1, type: F64, loc },
         type: F64,
         loc,
     };
-    const value = dynTarget ? { kind: "dynFrom", value: computed, type: DYN, loc } : computed;
-    return { kind: "assign", localId: target.id, value, loc };
+    return { kind: "assign", localId: target.id, value: computed, loc };
 }
 /** The shared tail of `x op= e` over a resolved variable/global target —
  * desugared to `x = x op e` (x read before e, like JS). Serves the bare-
@@ -7746,7 +7732,8 @@ export function lowerForOf(lowerer, stmt) {
         }
     }
     const elementType = iterable.type.kind === "array" ? iterable.type.elem : tupleSource.elem;
-    const yieldedT = tupleSource === null ? arrayValueType(lowerer, elementType) : elementType;
+    const privateSplit = !awaitArray && isPrivateSplitConsumer(lowerer, iterSrc, iterable);
+    const yieldedT = tupleSource === null && !privateSplit ? arrayValueType(lowerer, elementType) : elementType;
     let elemValueT = yieldedT;
     let awaitPromiseTag = null;
     if (awaitArray) {
@@ -7794,12 +7781,15 @@ export function lowerForOf(lowerer, stmt) {
     }
     // Native arrays retain their payload ABI; the loop binds the value yielded
     // by Get, which is undefined for both holes and present undefined slots.
-    const sourceT = iterable.type;
-    const source = lowerer.declareHiddenLocal("%arrayIterator", sourceT);
-    const cursor = lowerer.declareHiddenLocal("%arrayCursor", F64);
-    cursor.mutable = true;
     const forValues = (localId, body) => {
         const loc = locOf(stmt);
+        if (privateSplit) {
+            return { kind: "forOf", localId, iterable, body, ...(labels && { labels }), loc };
+        }
+        const sourceT = iterable.type;
+        const source = lowerer.declareHiddenLocal("%arrayIterator", sourceT);
+        const cursor = lowerer.declareHiddenLocal("%arrayCursor", F64);
+        cursor.mutable = true;
         const needsClose = awaitArray
             ? lowerer.declareHiddenLocal("%arrayIteratorNeedsClose", BOOL)
             : null;