@scriptc/compiler 0.2.5 → 0.2.7

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

@@ -1,3 +1,5 @@
+import { lowerUnionEquality, tagEqualityMayMissAlias } from "./strict-equality.js";
+import { lowerArrayCallbackCall } from "./containers/array-callback-call.js";
 /** Dispatch source calls, builtin members and receiver-specific operations.
  * Signature collection, argument completion and function bodies have their
  * own owners; this module selects the applicable call path. */
@@ -24,6 +26,7 @@ import { lowerGroupByStaticCall } from "./containers/collection-grouping.js";
 import { lowerIteratorHelperCall } from "./containers/iterator-helpers.js";
 import { lowerObjectAssignIndexShape, lowerObjectConstructor, lowerObjectFromEntriesCall, lowerObjectIterOverIndexShape, } from "./containers/indexed-objects.js";
 import { lowerTupleReadMethodCall } from "./containers/array-methods.js";
+import { tryFuseIndexRead } from "./array-values.js";
 import { lowerBytesStaticCall } from "./containers/bytes.js";
 import { lowerRegexMethodCall, lowerStringIndexCall, lowerStringMethodCall, lowerStringPaddingCall, lowerStringSplitCall, } from "./containers/string-and-regexp.js";
 import { createRequireSpecOf } from "./builtins/module-bindings.js";
@@ -1143,6 +1146,23 @@ export function lowerCall(lowerer, expr) {
             if (sig && !(jsSpreadArgs && spreadNeedsRuntimeArity(lowerer, sig.params, expr.arguments))) {
                 lowerer.noteEdge(sig.name);
                 const args = lowerer.completeArgs(expr.arguments, sig.params, loc, expr);
+                const symbol = lowerer.resolveValueSymbol(expr.expression);
+                const declaration = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
+                // A bare call supplies undefined as this, even inside a callback
+                // currently carrying a receiver. The value-call ABI saves and
+                // restores that ambient receiver around the function invocation.
+                if (declaration &&
+                    ts.isFunctionDeclaration(declaration) &&
+                    declaration.parameters.some(isThisParameter)) {
+                    const callee = lowerer.lowerExpr(expr.expression);
+                    return reconcileOverloadReturn(lowerer, expr, {
+                        kind: "callValue",
+                        callee,
+                        args,
+                        type: sig.returnType,
+                        loc,
+                    });
+                }
                 return reconcileOverloadReturn(lowerer, expr, {
                     kind: "call",
                     callee: sig.name,
@@ -1573,6 +1593,11 @@ export function lowerCall(lowerer, expr) {
         !symbolFieldInfo(lowerer, expr.expression)) {
         const access = expr.expression;
         const value = tryLowerExpression(lowerer, access.expression);
+        if (value?.type.kind === "array" && !isJsSourceFile(expr.getSourceFile())) {
+            const callback = lowerArrayCallbackCall(lowerer, expr, access, value);
+            if (callback)
+                return callback;
+        }
         if (value?.type.kind === "dyn" ||
             value?.type.kind === "generator" ||
             (value &&
@@ -1996,6 +2021,23 @@ function lowerNumberConstructorValue(lowerer, argNode, loc) {
         return { kind: "libCall", fn: "num.fromString", args: [arg], type: F64, loc };
     if (arg.type.kind === "dyn")
         return { kind: "libCall", fn: "dyn.numberConstructor", args: [arg], type: F64, loc };
+    // Number(strings[i]) without boxing `string | undefined`: a missing slot
+    // converts like undefined, to NaN.
+    const indexedString = arg.type.kind === "union" &&
+        arg.kind === "call" &&
+        arg.args[0]?.type.kind === "array" &&
+        arg.args[0].type.elem.kind === "string"
+        ? tryFuseIndexRead(lowerer, arg, F64, (read) => ({ kind: "libCall", fn: "num.fromString", args: [read], type: F64, loc }), {
+            kind: "bin",
+            op: "/",
+            left: { kind: "numLit", value: 0, type: F64, loc },
+            right: { kind: "numLit", value: 0, type: F64, loc },
+            type: F64,
+            loc,
+        })
+        : null;
+    if (indexedString)
+        return indexedString;
     if (arg.type.kind === "union" && lowerer.dynConvertible(arg.type))
         return {
             kind: "libCall",
@@ -2871,14 +2913,28 @@ function lowerOptionalStringNumber(lowerer, arg, loc, fn = "num.fromString", lab
 function lowerDynReceiverMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(call, access))
         return null;
-    if (stdlibGlobalNameOf(lowerer, access.expression) !== null)
-        return null;
+    if (stdlibGlobalNameOf(lowerer, access.expression) !== null) {
+        // A named builtin import can resolve to its ambient declaration, too.
+        // parentPort is an instance value whose methods use the native handle;
+        // it must work without a non-null assertion or a namespace spelling.
+        const binding = ts.isIdentifier(access.expression)
+            ? lowerer.builtinImportOf(access.expression)
+            : null;
+        if (binding?.module !== "worker_threads" || binding.member !== "parentPort")
+            return null;
+    }
     // Only checker-untyped receivers: `any`/`unknown`, or the `any[]` an
     // Array.isArray guard narrows them to (the value is STILL the checked-dynamic tree
     // array — scalar narrowings bridge through maybeNarrow's dynCheck and
     // take the ordinary typed paths, but there is no static home for an
     // any-elemented array). Typed receivers keep their own lowerings.
     const recvTs = lowerer.typeOf(access.expression);
+    if (lowerer.classImplementedProtocol(recvTs)) {
+        const property = lowerer.checker.getPropertyOfType(recvTs, access.name.text);
+        if (property &&
+            isGenericCallableMemberType(lowerer.checker.getTypeOfSymbol(property), lowerer.checker))
+            return lowerObjLitGenericMethodCall(lowerer, call, access);
+    }
     const recvSymbol = recvTs.getSymbol();
     if (recvSymbol &&
         ["MapIterator", "SetIterator"].includes(recvSymbol.name) &&
@@ -3458,6 +3514,11 @@ const DYN_DISPATCH_METHODS = new Set([
     "additionalHeaders",
     "altsvc",
     "origin",
+    // Worker and MessagePort methods use the owning context's handle adapter.
+    "postMessage",
+    "terminate",
+    "start",
+    "hasRef",
 ]);
 export function lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayReceiver) {
     const method = access.name.text;
@@ -4180,13 +4241,13 @@ function implicitReceiverOverloadReturn(lowerer, expr) {
 function reconcileOverloadReturn(lowerer, expr, call) {
     const rsig = lowerer.checker.getResolvedSignature(expr);
     const rdecl = rsig ? lowerer.checker.signatureDeclaration(rsig) : undefined;
-    // Fluent JS overrides share the base's return ABI, but their result
-    // still has the receiver's subclass layout at the call site.
+    // Nominal covariant overrides share the base's return ABI, but retain
+    // their declared subclass result at the call site. Unannotated fluent
+    // JS overrides use the same bridge for their proven receiver result.
     if (call.type.kind === "object" &&
         rdecl &&
         ts.isMethodDeclaration(rdecl) &&
-        isJsSourceFile(rdecl.getSourceFile()) &&
-        returnsOnlyThis(rdecl)) {
+        (!isJsSourceFile(rdecl.getSourceFile()) || returnsOnlyThis(rdecl))) {
         call = lowerer.maybeNarrow(call, expr);
     }
     const resolvedOverload = rsig &&
@@ -5684,11 +5745,10 @@ function filterNarrowHelper(lowerer, test, elem, outElem, tag, loc) {
  * no runtime walk. ORDER is the shape's first-seen DECLARATION order
  * (threaded through the shape registry), which matches Node whenever
  * objects are constructed in declaration order — the divergence for
- * reordered construction is SEMANTICS.md 36. Fields holding the
- * undefined arm of their union are SKIPPED at runtime (Node's missing
- * key: an unset optional never made it into the object), which also
- * means an EXPLICIT `{ a: undefined }` key is dropped where Node lists
- * it — same rule as jsonStringify, same SEMANTICS entry. Values wrap
+ * reordered construction is SEMANTICS.md 36. Optional fields that are
+ * absent (omitted or deleted) are SKIPPED at runtime, Node's missing key,
+ * while an explicit `{ a: undefined }` is listed with its undefined
+ * value. Values wrap
  * into the checker's result-element type per field; a multi-arm field
  * union that differs from the result union would need a re-tag — fenced.
  * Null when this isn't an Object static over a fixed record (index
@@ -5807,9 +5867,9 @@ function lowerSymbolMethodCall(lowerer, call, access) {
 }
 /** The interned keys-array helper over a FIXED record shape: a call of a
  * lifted helper whose body pushes each declared field name in first-seen
- * DECLARATION order, skipping fields currently holding the undefined arm
- * of their union at runtime (Node's missing key — an unset optional
- * never made it into the object; SEMANTICS.md 37's rules). ONE
+ * DECLARATION order, skipping optional fields that are currently absent
+ * (omitted or deleted — Node's missing key; a field explicitly holding
+ * undefined is present and listed). ONE
  * construction, interned per shape, shared by Object.keys and for-in —
  * for-in iterates exactly the keys Object.keys answers. */
 export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
@@ -5858,32 +5918,11 @@ export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
                     },
                     loc,
                 };
-                // Undefined-armed fields: the push is guarded by a tag test (the
+                // Fields that can be absent push behind their presence test (the
                 // key exists exactly when Object.keys would list it).
-                const utag = f.type.kind === "union" ? lowerer.armTag(f.type.unionId, UNDEFINED_T) : -1;
-                body.push(utag >= 0 && f.type.kind === "union"
-                    ? {
-                        kind: "if",
-                        cond: {
-                            kind: "unionIsTag",
-                            unionId: f.type.unionId,
-                            tag: utag,
-                            negated: true,
-                            value: {
-                                kind: "recordGet",
-                                obj: ref,
-                                shapeId: argIr.shapeId,
-                                field: f.name,
-                                type: f.type,
-                                loc,
-                            },
-                            type: BOOL,
-                            loc,
-                        },
-                        then: [pushStmt],
-                        else_: null,
-                        loc,
-                    }
+                const present = lowerer.recordFieldPresent(ref, argIr.shapeId, f.name, loc);
+                body.push(present.kind === "recordHas"
+                    ? { kind: "if", cond: present, then: [pushStmt], else_: null, loc }
                     : pushStmt);
             }
             body.push({ kind: "return", value: outRef, loc });
@@ -5897,9 +5936,9 @@ export function recordKeysArrayCall(lowerer, receiver, argIr, shape, loc) {
 }
 /** Interned `%obj.hasOwn.<n>(r, k)` — Object.hasOwn's membership walk
  * over a record shape: the key compares against each
- * declared field name, undefined-armed fields answering by their tag
+ * declared field name, optional fields answering by their presence
  * (a key is own exactly when Object.keys would list it — the two share
- * the guard), everything else true. Unmatched keys probe the overflow
+ * the test), everything else true. Unmatched keys probe the overflow
  * map when present, so explicit undefined values remain own keys. */
 function recordHasOwnHelper(lowerer, shapeId, loc) {
     const key = `obj.hasOwn:${shapeId}`;
@@ -5914,18 +5953,7 @@ function recordHasOwnHelper(lowerer, shapeId, loc) {
     const kRef = { kind: "varRef", localId: "k.0", type: STRING, loc };
     const body = [];
     for (const f of shape.fields) {
-        const utag = f.type.kind === "union" ? lowerer.armTag(f.type.unionId, UNDEFINED_T) : -1;
-        const answer = utag >= 0 && f.type.kind === "union"
-            ? {
-                kind: "unionIsTag",
-                unionId: f.type.unionId,
-                tag: utag,
-                negated: true,
-                value: { kind: "recordGet", obj: rRef, shapeId, field: f.name, type: f.type, loc },
-                type: BOOL,
-                loc,
-            }
-            : { kind: "boolLit", value: true, type: BOOL, loc };
+        const answer = lowerer.recordFieldPresent(rRef, shapeId, f.name, loc);
         body.push({
             kind: "if",
             cond: {
@@ -5963,8 +5991,9 @@ function recordHasOwnHelper(lowerer, shapeId, loc) {
 }
 /** Interned `%obj.assign.<n>(t, s)` — Object.assign's per-field copy
  * over signature-free records (every source field lands on a same-named,
- * same-typed target field — the caller's gate): undefined-armed source
- * fields copy behind the not-undefined guard, everything else straight,
+ * same-typed target field — the caller's gate): optional source fields
+ * copy only when present (an explicit undefined copies), everything else
+ * straight,
  * and the TARGET returns (JS's aliasing). */
 function recordAssignHelper(lowerer, targetShapeId, srcShapeId, loc) {
     const key = `obj.assign:${targetShapeId}:${srcShapeId}`;
@@ -5996,23 +6025,9 @@ function recordAssignHelper(lowerer, targetShapeId, srcShapeId, loc) {
             value: get,
             loc,
         };
-        const utag = f.type.kind === "union" ? lowerer.armTag(f.type.unionId, UNDEFINED_T) : -1;
-        body.push(utag >= 0 && f.type.kind === "union"
-            ? {
-                kind: "if",
-                cond: {
-                    kind: "unionIsTag",
-                    unionId: f.type.unionId,
-                    tag: utag,
-                    negated: true,
-                    value: get,
-                    type: BOOL,
-                    loc,
-                },
-                then: [set],
-                else_: null,
-                loc,
-            }
+        const present = lowerer.recordFieldPresent(sRef, srcShapeId, f.name, loc);
+        body.push(present.kind === "recordHas"
+            ? { kind: "if", cond: present, then: [set], else_: null, loc }
             : set);
     }
     body.push({ kind: "return", value: tRef, loc });
@@ -6290,6 +6305,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
             };
         }
         if (left.type.kind === "union" || right.type.kind === "union") {
+            const compared = lowerUnionEquality(lowerer, left, right, false, true, loc);
+            if (compared)
+                return compared;
             const ut = left.type.kind === "union" ? left.type : right.type;
             const bothUnion = left.type.kind === "union" && right.type.kind === "union";
             const sameUnion = bothUnion && typeEquals(left.type, right.type);
@@ -6297,9 +6315,16 @@ function lowerObjectStaticCall(lowerer, call, access) {
                 const plain = left.type.kind === "union" ? right : left;
                 const arms = lowerer.unions.get(ut.unionId)?.arms ?? [];
                 // The plain side wraps into the union exactly like === when the
-                // union holds its type; a plain PRIMITIVE the union has no arm
-                // for is the disjoint constant false (coercing it would strand).
-                if (bothUnion || arms.some((a) => typeEquals(a, plain.type))) {
+                // union holds its type, or when a plain class instance upcasts
+                // into exactly one class arm (the same pointer under a base tag);
+                // a plain PRIMITIVE the union has no arm for is the disjoint
+                // constant false (coercing it would strand).
+                const plainType = plain.type;
+                const upcastArm = plainType.kind === "object" &&
+                    arms.filter((a) => a.kind === "object" && lowerer.isSubclassOf(plainType.className, a.className)).length === 1;
+                if (bothUnion || upcastArm || arms.some((a) => typeEquals(a, plain.type))) {
+                    if (tagEqualityMayMissAlias(lowerer, ut))
+                        lowerer.noLowering("Object.is over related class values beside structural union members", call, NARROW_FIRST);
                     const sameValue = arms.some((a) => a.kind === "f64");
                     return {
                         kind: "unionEq",
@@ -6511,12 +6536,10 @@ function lowerObjectStaticCall(lowerer, call, access) {
         // (the mockable-clock restore: `Object.assign(mocked,
         // implementations)` over one shape): the per-field copy helper,
         // returning the TARGET — JS's aliasing, the target mutates in
-        // place. Undefined-armed source fields copy behind the
-        // not-undefined guard (an omitted optional field holds the
-        // undefined arm and must not erase the target's value — Node
-        // copies own keys only; an EXPLICIT `k: undefined` source diverges,
-        // the explicit-undefined-is-absent stance). Everything else keeps
-        // the spread hint.
+        // place. Optional source fields copy only when present (an omitted
+        // optional field must not erase the target's value — Node copies own
+        // keys only — while an explicit `k: undefined` does). Everything
+        // else keeps the spread hint.
         if (call.arguments.length === 2 && !call.arguments.some((a) => ts.isSpreadElement(a))) {
             const tProbe = tryLowerExpression(lowerer, call.arguments[0]);
             const sProbe = tryLowerExpression(lowerer, call.arguments[1]);
@@ -6893,11 +6916,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
     }
     // `Object.hasOwn(r, k)` over a RECORD receiver: a record's own-key set
     // is its declared field list, so membership is a compare chain against
-    // the field names (interned per shape). Undefined-armed (optional)
-    // fields answer by their runtime tag — the explicit-undefined-is-absent
-    // stance: an omitted optional field holds the undefined arm and reads
-    // as NOT own, exactly Node's absent key (an EXPLICIT `k: undefined`
-    // diverges — documented next to the child-env/JSON rule). Tuple
+    // the field names (interned per shape). Optional fields answer by
+    // their runtime presence: an omitted or deleted optional field is NOT
+    // own, while an explicit `k: undefined` is, exactly Node's keys. Tuple
     // and accessor-carrying shapes keep the SC2020 fence. Index-signature
     // records additionally probe the overflow map; non-record receivers
     // do too.
@@ -6907,6 +6928,19 @@ function lowerObjectStaticCall(lowerer, call, access) {
         const recvNode = call.arguments[0];
         const keyNode = call.arguments[1];
         const probed = tryLowerExpression(lowerer, recvNode);
+        const arrayKey = probed?.type.kind === "array" ? lowerer.lowerExpr(keyNode) : null;
+        if (probed?.type.kind === "array" && arrayKey?.type.kind === "f64") {
+            // Numeric own keys use the array's slot/property presence directly.
+            // Unlike `in`, this never includes inherited properties. arrayHas
+            // evaluates and keeps the receiver alive before evaluating the key.
+            return {
+                kind: "arrayHas",
+                arr: probed,
+                index: arrayKey,
+                type: BOOL,
+                loc: locOf(call),
+            };
+        }
         const constructor = probed?.type.kind === "classval" ? lowerer.classes.get(probed.type.className) : undefined;
         // A CHECKED-DYNAMIC receiver (the JS file-scope object-literal
         // identity story): the runtime dyn probe — OBJ member presence, ARR
@@ -6918,7 +6952,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
             (probed?.type.kind === "func" && lowerer.dynConvertible(probed.type))) {
             const loc = locOf(call);
             const receiver = lowerer.coerceToExpected(probed, DYN);
-            const rawKey = lowerer.lowerExpr(keyNode);
+            const rawKey = arrayKey ?? lowerer.lowerExpr(keyNode);
             if (rawKey.type.kind === "dyn" ||
                 rawKey.type.kind === "symbol" ||
                 (rawKey.type.kind === "union" && lowerer.dynConvertible(rawKey.type)))
@@ -7163,8 +7197,8 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     }
                     return null;
                 };
-                // Undefined-armed fields: the push is guarded by a tag test, and
-                // the pushed value is the narrowed non-undefined arm.
+                // Undefined-armed fields: the push is guarded by the field's
+                // presence; a narrowed push re-tags the non-undefined arm.
                 let guardUndefTag = null;
                 let value = raw;
                 let vt = f.type;
@@ -7215,46 +7249,83 @@ function lowerObjectStaticCall(lowerer, call, access) {
                     lowerer.unsupported("SC1090", call, `Object.${member} over '${lowerer.fmt(argIr)}' (field '${f.name}' of type '${lowerer.fmt(f.type)}' ` +
                         `cannot flow into the '${lowerer.fmt(valueT)}' result element — read the fields directly)`);
                 }
-                const pushed = member === "values"
-                    ? coerced
-                    : {
-                        kind: "recordLit",
-                        fields: [
-                            { name: "0", value: { kind: "strLit", value: f.name, type: STRING, loc } },
-                            { name: "1", value: coerced },
-                        ],
-                        type: tupleT,
-                        loc,
-                    };
-                const pushStmt = {
+                const pushOf = (element) => ({
                     kind: "exprStmt",
                     expr: {
                         kind: "arrIntrinsic",
                         method: "push",
                         receiver: outRef,
-                        args: [pushed],
+                        args: [
+                            member === "values"
+                                ? element
+                                : {
+                                    kind: "recordLit",
+                                    fields: [
+                                        { name: "0", value: { kind: "strLit", value: f.name, type: STRING, loc } },
+                                        { name: "1", value: element },
+                                    ],
+                                    type: tupleT,
+                                    loc,
+                                },
+                        ],
                         type: F64,
                         loc,
                     },
                     loc,
-                };
-                body.push(guardUndefTag !== null && f.type.kind === "union"
-                    ? {
-                        kind: "if",
-                        cond: {
-                            kind: "unionIsTag",
-                            unionId: f.type.unionId,
-                            tag: guardUndefTag,
-                            negated: true,
-                            value: raw,
-                            type: BOOL,
+                });
+                let stmt = pushOf(coerced);
+                if (guardUndefTag !== null && f.type.kind === "union") {
+                    if (value !== raw) {
+                        // A narrowed push: a present field holding undefined pushes
+                        // the result element's own undefined when it has one; a values
+                        // array without one stores a present undefined element (a
+                        // runtime-optional field the checker typed as required). An
+                        // entries tuple slot has no spelling for it.
+                        const undefinedElement = valueT ? lowerer.wrappedUndefined(valueT, loc) : null;
+                        const undefinedPush = undefinedElement
+                            ? pushOf(undefinedElement)
+                            : member === "values"
+                                ? {
+                                    kind: "arraySetUndefined",
+                                    arr: outRef,
+                                    index: {
+                                        kind: "arrIntrinsic",
+                                        method: "length",
+                                        receiver: outRef,
+                                        args: [],
+                                        type: F64,
+                                        loc,
+                                    },
+                                    loc,
+                                }
+                                : null;
+                        stmt = {
+                            kind: "if",
+                            cond: {
+                                kind: "unionIsTag",
+                                unionId: f.type.unionId,
+                                tag: guardUndefTag,
+                                negated: true,
+                                value: raw,
+                                type: BOOL,
+                                loc,
+                            },
+                            then: [stmt],
+                            else_: undefinedPush ? [undefinedPush] : null,
                             loc,
-                        },
-                        then: [pushStmt],
+                        };
+                    }
+                    // Absent fields contribute nothing; present ones push their
+                    // value, undefined included.
+                    stmt = {
+                        kind: "if",
+                        cond: lowerer.recordFieldPresent(ref, argIr.shapeId, f.name, loc),
+                        then: [stmt],
                         else_: null,
                         loc,
-                    }
-                    : pushStmt);
+                    };
+                }
+                body.push(stmt);
             }
             body.push({ kind: "return", value: outRef, loc });
             fn.body = body;
@@ -7323,7 +7394,7 @@ function lowerObjectAssignHybrid(lowerer, call) {
     for (const f of shape.fields) {
         const v = values.get(f.name);
         if (!v) {
-            const absent = lowerer.wrappedUndefined(f.type, loc);
+            const absent = lowerer.absentFieldValue(f.type, loc);
             if (!absent) {
                 lowerer.unsupported("SC1090", call, `Object.assign leaving the required field '${f.name}' of '${lowerer.fmt(mapped)}' unfilled`);
             }
@@ -7801,6 +7872,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
     // Use the lowered receiver's representation and retain its evaluation.
     const probe = mappedReceiver?.kind !== "object" &&
         (lowerer.implicitParamTypes !== null ||
+            lowerer.classImplementedProtocol(lowerer.typeOf(access.expression)) ||
             ts.isNewExpression(access.expression) ||
             isJsSourceFile(call.getSourceFile()))
         ? ts.isNewExpression(access.expression)
@@ -7922,7 +7994,9 @@ export function lowerObjectMethodCall(lowerer, call, access) {
             const receiverLocal = lowerer.declareHiddenLocal("%callReceiver", target.obj.type);
             const init = { kind: "varDecl", localId: receiverLocal.id, init: target.obj, loc };
             target.obj = { kind: "varRef", localId: receiverLocal.id, type: receiverLocal.type, loc };
-            const receiver = lowerer.coerceToExpected(target.obj, DYN);
+            const receiver = {};
+            if (!lowerer.receiverFreeCallbackFields.has(access.name.text))
+                receiver.receiver = lowerer.coerceToExpected(target.obj, DYN);
             const finish = (result) => ({
                 kind: "seqExpr",
                 stmts: [init],
@@ -7951,12 +8025,12 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                     const boxed = { kind: "dynFrom", value: callee, type: DYN, loc };
                     const spread = lowerSpreadArgsCall(lowerer, call, boxed, loc);
                     if (spread?.kind === "dynCall")
-                        return finish({ ...spread, receiver });
+                        return finish({ ...spread, ...receiver });
                     const args = call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN));
                     return finish({
                         kind: "dynCall",
                         callee: boxed,
-                        receiver,
+                        ...receiver,
                         calleeName: access.getText(),
                         args,
                         type: DYN,
@@ -7964,7 +8038,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                     });
                 }
                 const args = completeFuncValueArgs(lowerer, call, callee.type, locOf(call));
-                return finish({ kind: "callValue", callee, receiver, args, type: callee.type.ret, loc });
+                return finish({ kind: "callValue", callee, ...receiver, args, type: callee.type.ret, loc });
             }
             if (callee?.type.kind === "dyn") {
                 if (call.arguments.some((a) => ts.isSpreadElement(a))) {
@@ -7974,7 +8048,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                 return finish({
                     kind: "dynCall",
                     callee,
-                    receiver,
+                    ...receiver,
                     calleeName: access.getText(),
                     args,
                     type: DYN,
@@ -8056,7 +8130,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
                 type: found.sig.ret,
                 loc,
             };
-        const result = classCallbackCall(lowerer, value, method, call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), fallback, loc, access.getText());
+        const result = classCallbackCall(lowerer, value, method, call.arguments, fallback, loc, access.getText());
         return {
             kind: "seqExpr",
             stmts: [{ kind: "varDecl", localId: local.id, init: receiver, loc }],