@scriptc/compiler 0.2.6 → 0.2.8

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

@@ -10,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";
@@ -23,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";
@@ -37,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";
@@ -45,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";
@@ -3042,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",
@@ -3083,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 };
 }
@@ -3614,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;
         }
@@ -4020,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);
         }
@@ -4128,7 +4137,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
                 : immediatelyGuardedAbsenceProbe(lowerer, decl)
                     ? (lowerAbsenceProbe(lowerer, decl.initializer) ?? lowerer.lowerExpr(decl.initializer))
                     : lowerVariableInitializer(lowerer, decl.initializer, decl.type && (lowerer.typeOf(decl.name).flags & ts.TypeFlags.Never) === 0
-                        ? (lowerer.mapTypeOf(lowerer.typeOf(decl.name)) ?? undefined)
+                        ? annotatedInitializerTarget(lowerer, decl.name)
                         : undefined);
     }
     catch (e) {
@@ -4394,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;
     }
@@ -4528,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) {
@@ -4538,14 +4551,25 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
 }
+/** The destination an annotated declaration builds its initializer for:
+ * the declared type, or the record layout the optional-read analysis
+ * widened for fields a missing element can leave undefined. */
+function annotatedInitializerTarget(lowerer, name) {
+    const declared = lowerer.mapTypeOf(lowerer.typeOf(name));
+    if (!declared)
+        return undefined;
+    const widened = lowerer.runtimeOptionalBindingType(name, declared);
+    return lowerer.isRuntimeOptionalRecordVariant(widened, declared) ? widened : declared;
+}
 // lib.d.ts declares named captures as strings, but nonparticipating captures
 // are undefined. Inferred index records retain that runtime representation;
 // explicit annotations still require a checked conversion at the boundary.
 function inferredOptionalRecordType(lowerer, decl, declared, actual) {
-    if (decl.type ||
-        hasJsTypeAnnotation(decl) ||
-        declared.kind !== "record" ||
-        actual.kind !== "record")
+    if (decl.type || hasJsTypeAnnotation(decl))
+        return declared;
+    if (lowerer.isRuntimeOptionalRecordVariant(actual, declared))
+        return actual;
+    if (declared.kind !== "record" || actual.kind !== "record")
         return declared;
     const target = lowerer.shapes.get(declared.shapeId);
     const source = lowerer.shapes.get(actual.shapeId);
@@ -5016,8 +5040,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) {
@@ -5133,14 +5158,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)
@@ -5150,7 +5174,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",
@@ -5964,7 +5988,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);
@@ -6162,27 +6186,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");
         }
@@ -6269,22 +6273,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-
@@ -7745,7 +7744,17 @@ export function lowerForOf(lowerer, stmt) {
     }
     const elementType = iterable.type.kind === "array" ? iterable.type.elem : tupleSource.elem;
     const privateSplit = !awaitArray && isPrivateSplitConsumer(lowerer, iterSrc, iterable);
-    const yieldedT = tupleSource === null && !privateSplit ? arrayValueType(lowerer, elementType) : elementType;
+    // An array the optional-read analysis proved free of holes and stored
+    // undefined yields its payload directly, with no per-element state test.
+    const presentElements = tupleSource === null &&
+        !privateSplit &&
+        !awaitArray &&
+        elementType.kind !== "dyn" &&
+        elementType.kind !== "jsval" &&
+        lowerer.presentElementLoops.has(stmt);
+    const yieldedT = tupleSource === null && !privateSplit && !presentElements
+        ? arrayValueType(lowerer, elementType)
+        : elementType;
     let elemValueT = yieldedT;
     let awaitPromiseTag = null;
     if (awaitArray) {
@@ -7840,6 +7849,15 @@ export function lowerForOf(lowerer, stmt) {
                 };
             }
         }
+        else if (presentElements) {
+            yielded = {
+                kind: "arrayGet",
+                arr: varRef(source.id, sourceT, loc),
+                index: varRef(cursor.id, F64, loc),
+                type: elementType,
+                loc,
+            };
+        }
         else {
             yielded = arrayValueRead(lowerer, varRef(source.id, sourceT, loc), varRef(cursor.id, F64, loc), elementType, loc);
         }