@scriptc/compiler 0.4.8 → 0.4.9

package/dist/frontend/lowering/expressions/element-access.js

@@ -4,9 +4,11 @@ import { lowerUnionTupleRead } from "./union-fields.js";
 import { constituentTypes } from "../../ts7/checker.js";
 import * as ts from "../../ts7/adapter.js";
 import { lowerOptionalIndex, splitUndefinedIndex, undefinedTypedArrayKeyFence, } from "../undefined-index.js";
+import { callableBox, isCallableTableValue } from "../callable-properties.js";
 import { jsFuncNameOf, neverTaintedJsType } from "../lowerer.js";
-import { BOOL, DYN, F64, NULL_T, STRING, UNDEFINED_T, VOID, canBoxFuncIntoDyn, canDynCheckTo, isDynTypedRefType, isUnitType, recordTextCodecClass, shapeHasAccessorSlots, typeEquals, typeKey, unionContainerArmsOk, } from "../../../ir/ir.js";
+import { BOOL, DYN, F64, NULL_T, STRING, UNDEFINED_T, VOID, canBoxFuncIntoDyn, canDynCheckTo, isDynTypedRefType, isUnitType, recordTextCodecClass, shapeHasAccessorSlots, typeEquals, sortArms, typeKey, unionContainerArmsOk, } from "../../../ir/ir.js";
 import { importMetaField, isImportMeta } from "../import-meta.js";
+import { boxedHandleReceiver, lowerHandlePropertyWrite } from "../handle-properties.js";
 import { heldEnvValueType } from "../builtins/environment.js";
 import { hasOptionalChainGuard, isOptionalChainTail } from "./optional-chains.js";
 import { lowerEnumAccess } from "../lower-enums.js";
@@ -19,12 +21,12 @@ import { hostGlobalValue } from "../host-global-values.js";
 import { isJsSourceFile, locOf } from "../../program.js";
 import { MUTABLE_BUFFER_MEMBERS } from "../buffers.js";
 import { lowerGlobalObjectValue } from "../lower-global-value.js";
-import { expandoMemberRead } from "../lower-expando.js";
+import { fenceExpandoRead } from "../lower-expando.js";
 import { assertedElementKeepsUndefined, compoundUnsupported, concatOperand, dynCompoundValue, hasClassPayload, lowerDynMemberAssignment, lowerOptionalArrayIndexRead, lowerOptionalNumber, assertedReadObservesUndefined, recordKeyResultOk, representedClassFieldTarget, runtimeOptionalElementKey, symbolFieldTarget, } from "../lower-exprs.js";
 import { hasRuntimeStatics } from "../class-runtime-statics.js";
 import { tryLowerExpression } from "./try-lower-expression.js";
 import { assertedMemberRead, classFieldTarget, lowerUnionKeyedRead } from "./property-access.js";
-import { assertedProbeAccessOf, assertedReceiverNode, probeMemberName, } from "./asserted-receiver.js";
+import { assertedOnlyMemberWrite, assertedProbeAccessOf, assertedReceiverNode, probeMemberName, } from "./asserted-receiver.js";
 import { arrayNumberRead, arrayValueRead, arrayValueStore, arrayValueType, elementMayBeForeign, lowerSafeBytesRead, lowerSafeIndexRead, primitiveElement, unionArrayValueRead, unaffectedByIndex, } from "../array-values.js";
 import { lowerOptionalStringIndex, lowerUnionStringIndex } from "../string-index.js";
 import { InternalCompilerError } from "../../../errors.js";
@@ -278,13 +280,10 @@ export function lowerElementAccess(lowerer, expr) {
     }
     // Expando function members in element clothing (`foo[strMem]`,
     // `foo[_private]` where foo is a module-level function/callable const
-    // and the key folds or is a unique-symbol const): the member's module
-    // global — the dotted read's twin (lower-expando.ts).
-    {
-        const ex = expandoMemberRead(lowerer, expr);
-        if (ex)
-            return lowerer.maybeNarrow(ex, expr);
-    }
+    // and the key folds or is a unique-symbol const): only the source-order
+    // fence lives here (lower-expando.ts); the read itself is the ordinary
+    // element read of the closure's own-property table.
+    fenceExpandoRead(lowerer, expr);
     // Symbol-keyed property READS (`this[kLimit]`): when the key is a
     // statically-resolvable symbol declared as a field of the receiver's
     // class (classSymbolKeyOf — the countdown.js/OpenTUI idioms), the
@@ -1619,7 +1618,7 @@ function joinedFieldType(lowerer, fields) {
             return null;
     if (arms.length === 0)
         return null;
-    arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+    sortArms(arms);
     return arms.length === 1 ? arms[0] : { kind: "union", unionId: lowerer.unions.intern(arms) };
 }
 /** `r[k]` where the key type is a FINITE union of literal keys naming a
@@ -1736,7 +1735,7 @@ function lowerTupleIndexRead(lowerer, expr, obj, shapeId, shape, loc) {
     if (arms.some((a) => a.kind === "void" || a.kind === "generator" || a.kind === "caught")) {
         lowerer.unsupported("SC1090", expr, `dynamic tuple indexing of '${lowerer.fmt({ kind: "record", shapeId })}' (an element type has no value representation)`);
     }
-    arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+    sortArms(arms);
     if (arms.length > 1 && !unionContainerArmsOk(arms)) {
         lowerer.unsupported("SC1090", expr, `dynamic tuple indexing of '${lowerer.fmt({ kind: "record", shapeId })}' (the element types have no one native representation)`);
     }
@@ -1793,6 +1792,7 @@ function lowerTupleIndexRead(lowerer, expr, obj, shapeId, shape, loc) {
 export function lowerElementCompoundParts(lowerer, expr, op, statement) {
     const target = expr.left;
     fenceNodeModuleMutation(lowerer, target, "assignment");
+    fenceAssertedOnlyKeyedWrite(lowerer, target);
     const loc = locOf(expr);
     // A record through a computed key (`totals[side] += n` with a literal
     // union key, `counts[name] += 1` on an index-signature record): the
@@ -1800,14 +1800,24 @@ export function lowerElementCompoundParts(lowerer, expr, op, statement) {
     if (isKeyedFieldAccess(lowerer, target))
         return { expr: lowerFieldCompoundValue(lowerer, target, op, expr.right, loc), stmts: null };
     const checked = lowerer.lowerExpr(target.expression);
-    if (checked?.type.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(expr))) {
+    // A typed callable's element is its own-property table entry: the same
+    // read-modify-write the checked-dynamic receiver takes, through the
+    // identity-preserving box (`fn[k] += 1`, `fn[k] -= 1`).
+    const callableElement = checked !== null &&
+        checked !== undefined &&
+        checked.type.kind === "func" &&
+        isCallableTableValue(lowerer, target.expression, checked);
+    const dynReceiver = callableElement ? callableBox(lowerer, checked) : checked;
+    if (dynReceiver &&
+        (callableElement ||
+            (checked?.type.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(expr))))) {
         const stmts = [];
         const save = (value, name) => {
             const local = lowerer.declareHiddenLocal(name, value.type);
             stmts.push({ kind: "varDecl", localId: local.id, init: value, loc });
             return varRef(local.id, value.type, loc);
         };
-        const receiver = save(checked, "%compoundReceiver");
+        const receiver = save(dynReceiver, "%compoundReceiver");
         const key = save(lowerer.lowerExprExpecting(target.argumentExpression, DYN), "%compoundKey");
         const old = save({ kind: "dynKeyGet", value: receiver, key, type: DYN, loc }, "%compoundOld");
         const rhs = lowerer.lowerExprExpecting(expr.right, DYN);
@@ -2045,12 +2055,23 @@ function arrayStringOperand(arr, index, loc) {
         loc,
     };
 }
+/** A keyed write of a member only the receiver's asserted type declares
+ * (`x["icons"] = v`): refused by name, the write twin of
+ * assertedOptionalMemberRead. Node adds the property to the object; the
+ * record the binding holds has no slot for it. */
+function fenceAssertedOnlyKeyedWrite(lowerer, target) {
+    const member = recordKeyLiteralText(target.argumentExpression) ??
+        recordKeyTypeLiteralText(lowerer, target.argumentExpression);
+    if (member !== null)
+        assertedOnlyMemberWrite(lowerer, target.expression, member, target);
+}
 export function lowerElementWrite(lowerer, expr) {
     const prototype = lowerClassPrototypeComputedAssignment(lowerer, expr);
     if (prototype)
         return { kind: "exprStmt", expr: prototype, loc: locOf(expr) };
     const target = expr.left;
     fenceNodeModuleMutation(lowerer, target, "assignment");
+    fenceAssertedOnlyKeyedWrite(lowerer, target);
     const globalKey = globalSymbolKey(lowerer, target.expression, target.argumentExpression);
     if (globalKey) {
         const value = lowerer.lowerExprExpecting(expr.right, DYN);
@@ -2106,6 +2127,17 @@ export function lowerElementWrite(lowerer, expr) {
                 expr: lowerDynMemberAssignment(lowerer, expr, receiver),
                 loc: locOf(expr),
             };
+        // `fn[SYMBOL] = v` on a typed callable: a symbol-keyed own property of
+        // the closure's table, the computed keyed store the `any` view emits.
+        if (isCallableTableValue(lowerer, target.expression, receiver)) {
+            const boxed = callableBox(lowerer, receiver);
+            if (boxed)
+                return {
+                    kind: "exprStmt",
+                    expr: lowerDynMemberAssignment(lowerer, expr, boxed),
+                    loc: locOf(expr),
+                };
+        }
         if (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
             receiver.type.kind === "object" &&
             lowerer.dynConvertible(receiver.type)) {
@@ -2118,6 +2150,13 @@ export function lowerElementWrite(lowerer, expr) {
         lowerer.unsupported("SC1090", target, "symbol-keyed property writes outside class fields keyed by a stable module-level literal Symbol()/Symbol.for() (other static shapes have no symbol-keyed storage)");
     }
     const checkedReceiver = tryLowerExpression(lowerer, target.expression);
+    // `m[k] = v` over a typed handle in JavaScript: a property table entry
+    // of the handle (scr_dyn_handle_props.c).
+    {
+        const boxed = boxedHandleReceiver(lowerer, checkedReceiver);
+        if (boxed)
+            return lowerHandlePropertyWrite(lowerer, boxed, lowerer.lowerExprExpecting(target.argumentExpression, DYN), expr.right, locOf(expr));
+    }
     if (checkedReceiver?.type.kind === "dyn") {
         return {
             kind: "exprStmt",
@@ -2125,6 +2164,16 @@ export function lowerElementWrite(lowerer, expr) {
             loc: locOf(expr),
         };
     }
+    // `fn[k] = v` on a typed callable: the closure's own-property table.
+    if (checkedReceiver && isCallableTableValue(lowerer, target.expression, checkedReceiver)) {
+        const boxed = callableBox(lowerer, checkedReceiver);
+        if (boxed)
+            return {
+                kind: "exprStmt",
+                expr: lowerDynMemberAssignment(lowerer, expr, boxed),
+                loc: locOf(expr),
+            };
+    }
     if (checkedReceiver?.type.kind === "object" && isJsSourceFile(ts.getSourceFileOfNode(expr))) {
         const info = lowerer.classes.get(checkedReceiver.type.className);
         const key = recordKeyLiteralText(target.argumentExpression) ??