@scriptc/compiler 0.2.1 → 0.2.2

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

@@ -10,7 +10,7 @@ import { bodyReadsArguments } from "../arguments-usage.js";
 import { lowerGenMethodCall } from "./lower-generators.js";
 import { lowerClassSymbolMethodCall } from "./symbol-methods.js";
 import { errorToStringCall } from "./error-methods.js";
-import { lowerClassPrototypeAssign } from "./class-prototypes.js";
+import { lowerClassPrototypeAssign, lowerClassPrototypeDescriptors } from "./class-prototypes.js";
 import { BYTES_ELEMENT_NAME, BIGINT_T, BOOL, CAUGHT, DYN, F64, JSVAL, NULL_T, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, canMarshalTypedFuncIntoIsland, ffiClassType, ffiSourceParamTypes, funcOf, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
 import { isJsSourceFile, isNodeEsmFile, locOf, requireSpecOf } from "../program.js";
 import { genResultRecord, isGenericCallableMemberType, jsOpenObjectType, typeKey } from "../type-mapper.js";
@@ -45,6 +45,9 @@ import { fenceSymbolFieldCopy } from "./symbol-fields.js";
 import { lowerClassDataDescriptor, lowerClassDescriptorRead } from "./class-descriptors.js";
 import { classStaticDataFor } from "./class-static-data.js";
 import { jsBindingHasOpenWrites } from "./lower-stmts.js";
+import { functionCanReturnUndefined } from "../function-completion.js";
+import { checkedIterableSpread } from "./checked-iterable-spread.js";
+import { lowerUrlFactory } from "./lower-url.js";
 export { bodyReadsArguments };
 /** The one func-type projection of completed parameter shapes. Typed rest
  * parameters keep their packed array as the trailing native ABI slot and
@@ -125,6 +128,23 @@ export const MAX_GENERIC_INSTANCES = 100;
    * - `...xs: T[]`: the ABI type is the array; call sites pack the surplus.
    */
 export function paramShape(lowerer, param) {
+    if (isJsSourceFile(param.getSourceFile()) && ts.isSetAccessorDeclaration(param.parent))
+        return { type: DYN, mode: "required" };
+    if (isJsSourceFile(param.getSourceFile()) && ts.isConstructorDeclaration(param.parent) && !param.dotDotDotToken) {
+        // Reflective JavaScript construction can supply values outside the
+        // constructor's documented usual types. Retain the actual arguments
+        // and apply checked conversions only at operations that need them.
+        return param.initializer ? { type: DYN, mode: "omittable", bodyType: DYN }
+            : { type: DYN, mode: param.questionToken ? "omittable" : "required" };
+    }
+    const executor = param.parent;
+    const construction = executor?.parent;
+    const nativeExecutor = executor && (ts.isArrowFunction(executor) || ts.isFunctionExpression(executor)) && ts.isNewExpression(construction) &&
+        construction.arguments?.[0] === executor && lowerer.isStdlibGlobal(construction.expression, "Promise");
+    if (!nativeExecutor && isJsSourceFile(param.getSourceFile()) && !param.type && !param.dotDotDotToken && !ts.isSetAccessorDeclaration(param.parent) &&
+        !/@(?:param|type)\b/.test(param.getSourceFile().text.slice(param.parent?.pos ?? param.pos, param.getStart()))) {
+        return param.initializer ? { type: DYN, mode: "omittable", bodyType: DYN } : { type: DYN, mode: "required" };
+    }
     if (param.initializer && isJsSourceFile(param.getSourceFile()) && !param.type &&
         !/@(?:param|type)\b/.test(param.getSourceFile().text.slice(param.parent?.pos ?? param.pos, param.getStart()))) {
         return { type: DYN, mode: "omittable", bodyType: DYN };
@@ -219,9 +239,39 @@ export function paramShape(lowerer, param) {
     }
     if (param.initializer) {
         const raw = lowerer.irTypeOf(param.name);
+        // An optional JS array parameter is a live caller-owned buffer,
+        // including typed arrays passed through checked callbacks. Extracting
+        // a native array here would copy it and discard element writes.
+        if (isJsSourceFile(param.getSourceFile()) && !param.type &&
+            (raw.kind === "array" || raw.kind === "union" && lowerer.unions.get(raw.unionId)?.arms.some((arm) => arm.kind === "array"))) {
+            return { type: DYN, mode: "omittable", bodyType: DYN };
+        }
         return defaultParameterShape(lowerer, param, raw);
     }
-    const type = lowerer.runtimeOptionalBindingType(param.name, lowerer.irTypeOf(param.name));
+    let type = lowerer.runtimeOptionalBindingType(param.name, lowerer.irTypeOf(param.name));
+    const body = param.parent?.body;
+    if (isJsSourceFile(param.getSourceFile()) && body &&
+        type.kind !== "dyn" && type.kind !== "jsval") {
+        const symbol = lowerer.checker.getSymbolAtLocation(param.name);
+        let acceptsUndefined = false;
+        ts.walkPreorder(body, (node) => {
+            if (acceptsUndefined || !ts.isBinaryExpression(node))
+                return;
+            const op = node.operatorToken.kind;
+            if (op !== ts.SyntaxKind.EqualsEqualsEqualsToken && op !== ts.SyntaxKind.ExclamationEqualsEqualsToken &&
+                op !== ts.SyntaxKind.EqualsEqualsToken && op !== ts.SyntaxKind.ExclamationEqualsToken)
+                return;
+            const checks = (value, absent) => ts.isIdentifier(value) && ts.isIdentifier(absent) && absent.text === "undefined" &&
+                (lowerer.typeOf(absent).flags & ts.TypeFlags.Undefined) !== 0 &&
+                lowerer.checker.getSymbolAtLocation(value) === symbol;
+            acceptsUndefined = checks(node.left, node.right) || checks(node.right, node.left);
+        });
+        // A JavaScript body that handles an absent argument defines a wider
+        // contract than its JSDoc's usual value. Checked callers must deliver
+        // undefined to that branch rather than reject it at the ABI boundary.
+        if (acceptsUndefined)
+            type = lowerer.promoteRuntimeOptionalParameter(param.name, type);
+    }
     if (type.kind === "void") {
         return { type: DYN, mode: param.questionToken ? "omittable" : "required" };
     }
@@ -368,7 +418,7 @@ leading) {
                 // before conversion to the dense checked-dynamic argument pack.
                 value = { kind: "arrayLit", elems: [value], spreads: [0], type: value.type, loc: value.loc };
             }
-            value = lowerer.coerceInto(arg.expression, value, DYN);
+            value = checkedIterableSpread(lowerer, value, arg.expression.getText(), loc);
             if (spreads === 1 && index === argNodes.length - 1) {
                 stmts.push({ kind: "exprStmt", expr: {
                         kind: "libCall", fn: "dyn.packPushSpread", args: [ref(), value, { kind: "strLit", value: arg.expression.getText(), type: STRING, loc }], type: VOID, loc,
@@ -892,6 +942,8 @@ function producesConstructor(lowerer, type) {
     return false;
 }
 export function declaredReturnType(lowerer, decl, blame) {
+    if (isJsSourceFile(decl.getSourceFile()) && ts.isGetAccessorDeclaration(decl))
+        return DYN;
     const sig = lowerer.checker.getSignatureFromDeclaration(decl);
     if (!sig)
         lowerer.unsupported("SC1090", decl, "this function form");
@@ -906,11 +958,36 @@ export function declaredReturnType(lowerer, decl, blame) {
     // (`.action(() => { throw ... })`). `never` VALUES stay unmapped.
     if (retTsType.flags & ts.TypeFlags.Never)
         return VOID;
-    const mappedReturn = lowerer.mapTypeOf(retTsType);
-    if (isJsSourceFile(decl.getSourceFile()) && mappedReturn?.kind === "array" && mappedReturn.elem.kind === "f64")
+    let mappedReturn = lowerer.mapTypeOf(retTsType);
+    if (isJsSourceFile(decl.getSourceFile()) && decl.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) &&
+        !decl.asteriskToken && mappedReturn?.kind !== "promise") {
+        const fallback = dynFallbackType(lowerer, decl, retTsType);
+        return fallback?.kind === "promise" ? fallback : { kind: "promise", inner: DYN };
+    }
+    if (mappedReturn && isJsSourceFile(decl.getSourceFile()) && functionCanReturnUndefined(decl))
+        mappedReturn = lowerer.withUndefinedArmOf(mappedReturn) ?? mappedReturn;
+    if (isJsSourceFile(decl.getSourceFile()) && mappedReturn?.kind === "void") {
+        let returnsValue = false;
+        const scan = (node) => {
+            if (node !== decl && ts.isFunctionLike(node))
+                return;
+            if (ts.isReturnStatement(node) && node.expression)
+                returnsValue = true;
+            node.forEachChild(scan);
+        };
+        scan(decl);
+        if (returnsValue)
+            return DYN;
+    }
+    if (isJsSourceFile(decl.getSourceFile()) && mappedReturn?.kind === "array")
+        return DYN;
+    if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasExplicitJsDocReturn(decl) && mappedReturn?.kind === "record")
         return DYN;
     if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasExplicitJsDocReturn(decl) && mappedReturn?.kind === "date")
         return DYN;
+    if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasExplicitJsDocReturn(decl) &&
+        mappedReturn?.kind === "union" && lowerer.unions.get(mappedReturn.unionId)?.arms.some((arm) => arm.kind === "func"))
+        return DYN;
     // JS inference assigns Number to arithmetic over any, although the
     // runtime operands can both be BigInts. Preserve that native result.
     if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasExplicitJsDocReturn(decl) &&
@@ -971,7 +1048,7 @@ export function declaredReturnType(lowerer, decl, blame) {
     // Native-only members (such as Int32Array layout offsets) cannot cross
     // that boundary; their factories keep the native record ABI.
     const asyncReturn = decl.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) && mappedReturn?.kind === "promise";
-    const recordReturn = asyncReturn ? mappedReturn.inner : mappedReturn;
+    const recordReturn = asyncReturn && mappedReturn?.kind === "promise" ? mappedReturn.inner : mappedReturn;
     const recordArms = recordReturn?.kind === "union" ? lowerer.unions.get(recordReturn.unionId)?.arms : recordReturn ? [recordReturn] : undefined;
     const inferredRecordReturn = recordArms?.some((arm) => arm.kind === "record" || arm.kind === "object") &&
         recordArms.every((arm) => isUnitType(arm) || arm.kind === "record" || arm.kind === "object" && !hasExplicitJsDocReturn(decl));
@@ -985,7 +1062,7 @@ export function declaredReturnType(lowerer, decl, blame) {
         })) {
         return asyncReturn ? { kind: "promise", inner: DYN } : DYN;
     }
-    const returnType = lowerer.mapTypeOf(retTsType);
+    const returnType = mappedReturn;
     if (!returnType) {
         // JS inference residue (an `any` return, an unmappable union): the
         // checked-dynamic fallback, exactly the declaration story in
@@ -2097,6 +2174,12 @@ function implicitDeclaredReturn(lowerer, info) {
         if (retTs.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined))
             return DYN;
         if (lowerer.checker.isArrayType(retTs)) {
+            // Inferred JavaScript arrays can hold values selected through a
+            // mutable constructor registry. The checker may retain only one
+            // constructor's element type; settle the result from the lowered
+            // container instead of checking every element against that guess.
+            if (!hasExplicitJsDocReturn(info.decl))
+                return null;
             if (info.decl.parameters.some((param, index) => info.implicitParams?.[index] &&
                 lowerer.mapTypeOf(lowerer.typeOf(param.name))?.kind === "array"))
                 return null;
@@ -2110,6 +2193,12 @@ function implicitDeclaredReturn(lowerer, info) {
                 return null;
         }
         const mapped = lowerer.mapTypeOf(retTs);
+        // Mixed inferred results can select a closure or a class instance.
+        // Their callable ABI is settled by the lowered body, including native
+        // classes whose reflected calls return checked values.
+        if (mapped?.kind === "union" && !hasExplicitJsDocReturn(info.decl) &&
+            lowerer.unions.get(mapped.unionId)?.arms.some((arm) => arm.kind === "func"))
+            return null;
         if (mapped?.kind === "symbol" && !hasExplicitJsDocReturn(info.decl))
             return null;
         if (mapped?.kind === "date" && !hasExplicitJsDocReturn(info.decl))
@@ -2206,12 +2295,25 @@ function storedImplicitArgumentType(lowerer, arg) {
         return DYN;
     if (ts.isIdentifier(arg))
         return lowerer.peekLocal(arg)?.type ?? lowerer.globalOf(arg)?.type ?? null;
+    if (isJsSourceFile(arg.getSourceFile()) &&
+        (ts.isPropertyAccessExpression(arg) || ts.isElementAccessExpression(arg))) {
+        // Mutable JS members can retain an initializer-only checker type (for
+        // example a linked-list slot initially null). Specialize to the value
+        // we actually represent, rather than checking it back into that type.
+        const represented = tryLowerExpression(lowerer, arg);
+        if (represented)
+            return represented.type;
+    }
+    if (isJsSourceFile(arg.getSourceFile()) && (ts.isCallExpression(arg) || ts.isConditionalExpression(arg) ||
+        ts.isBinaryExpression(arg) && (arg.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
+            arg.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || arg.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken))) {
+        // Calls and fallback expressions can retain checked storage wider than
+        // the checker's inference (for example Object.assign on a JS instance).
+        const represented = tryLowerExpression(lowerer, arg);
+        if (represented?.type.kind === "dyn" || represented?.type.kind === "func")
+            return represented.type;
+    }
     if (ts.isCallExpression(arg) && ts.isIdentifier(arg.expression)) {
-        if (isJsSourceFile(arg.getSourceFile())) {
-            const represented = tryLowerExpression(lowerer, arg);
-            if (represented?.type.kind === "dyn" || represented?.type.kind === "func")
-                return represented.type;
-        }
         const callee = storedImplicitArgumentType(lowerer, arg.expression);
         if (callee?.kind === "dyn")
             return DYN;
@@ -3852,6 +3954,7 @@ export function lowerCall(lowerer, expr) {
         lowerer.fenceStaticReadableStreamMember(access, "call");
         const source = tryLowerExpression(lowerer, access.expression);
         if (source && (source.type.kind === "dyn" || source.type.kind === "func" ||
+            source.type.kind === "union" && isJsSourceFile(expr.getSourceFile()) && lowerer.dynConvertible(source.type) ||
             (source.type.kind === "map" || source.type.kind === "set") && lowerer.dynConvertible(source.type) || isDynTypedRefType(source.type) &&
             lowerer.foldedStringKeyOf(access.argumentExpression) === null &&
             lowerer.mapTypeOf(lowerer.typeOf(access.argumentExpression))?.kind !== "symbol")) {
@@ -4238,6 +4341,9 @@ export function lowerCall(lowerer, expr) {
             if (name === "parseFloat" && probed?.type.kind === "string") {
                 return { kind: "libCall", fn: "num.parseFloat", args: [probed], type: F64, loc };
             }
+            if (name === "parseFloat" && probed?.type.kind === "dyn") {
+                return { kind: "libCall", fn: "num.parseFloat", args: [{ kind: "libCall", fn: "dyn.toStringCoerce", args: [probed], type: STRING, loc }], type: F64, loc };
+            }
             if (name === "isFinite" && probed?.type.kind === "f64") {
                 return { kind: "libCall", fn: "number.isFinite", args: [probed], type: BOOL, loc };
             }
@@ -4565,6 +4671,7 @@ export function lowerCall(lowerer, expr) {
             // Before the island path: regex-argument replace/replaceAll/split
             // lower STATICALLY; only the string-pattern overloads are island.
             lowerRegexMethodCallWithOptionalArg(lowerer, expr, expr.expression) ??
+            lowerUrlStaticCall(lowerer, expr, expr.expression) ??
             lowerer.lowerUrlMethodCall(expr, expr.expression) ??
             lowerer.lowerSearchParamsMethodCall(expr, expr.expression) ??
             lowerer.lowerStatsMethodCall(expr, expr.expression) ??
@@ -4615,9 +4722,6 @@ export function lowerCall(lowerer, expr) {
             lowerer.lowerBytesMethodCall(expr, expr.expression) ??
             lowerBytesStaticCall(lowerer, expr, expr.expression) ??
             lowerBufferStaticCallWithNarrowedArg(lowerer, expr, expr.expression) ??
-            // URL.revokeObjectURL's zero-argument contract (the one-argument
-            // form keeps the fence — createObjectURL does too).
-            lowerUrlStaticCall(lowerer, expr, expr.expression) ??
             // Readable.from — the stream classes' one static (before the
             // stdlib chokepoint claims the member).
             lowerStreamStaticCall(lowerer, expr, expr.expression) ??
@@ -5760,7 +5864,7 @@ function lowerSpreadArgsCall(lowerer, expr, callee, loc) {
                 // The spelling rides along for V8's nullish spread-call
                 // TypeError ("v is not iterable (cannot read property ...)").
                 spreads.push({ arg: args.length, what: p.spreadOf.getText() });
-                args.push(lowerer.coerceInto(p.spreadOf, p.v, DYN));
+                args.push(checkedIterableSpread(lowerer, p.v, p.spreadOf.getText(), loc));
             }
             else {
                 args.push(lowerer.coerceInto(p.node, p.v, DYN));
@@ -5770,7 +5874,7 @@ function lowerSpreadArgsCall(lowerer, expr, callee, loc) {
         return { kind: "dynCall", callee: boxed, calleeName, args, spreads, type: DYN, loc };
     }
     if (spreadParts.length > 0 &&
-        spreadParts.every((p) => p.v.type.kind === "jsval") &&
+        (spreadParts.every((p) => p.v.type.kind === "jsval") || callee.type.kind === "func" && callee.type.restAbi === "jsval") &&
         (callee.type.kind === "jsval" || callee.type.kind === "func")) {
         if (spreadParts.length !== 1 || parts[parts.length - 1].spreadOf === null) {
             lowerer.unsupported("SC1090", expr, "spread arguments before positional arguments in island calls (one trailing spread after the fixed arguments is the supported form)");
@@ -5783,7 +5887,7 @@ function lowerSpreadArgsCall(lowerer, expr, callee, loc) {
         const last = parts[parts.length - 1];
         // The spelling rides in `name` for V8's nullish spread-call
         // TypeError ("v is not iterable (cannot read property ...)").
-        return { kind: "jsOp", op: "callSpread", name: last.spreadOf.getText(), args: [f, preArr, last.v], type: JSVAL, loc };
+        return { kind: "jsOp", op: "callSpread", name: last.spreadOf.getText(), args: [f, preArr, lowerer.coerceInto(last.spreadOf, last.v, JSVAL)], type: JSVAL, loc };
     }
     // No lane fits (a spread source outside both tiers, a callee neither
     // boxable nor marshalable, mixed dyn/jsval spreads): fence HERE — the
@@ -5835,12 +5939,21 @@ function canCompleteRuntimeSpread(lowerer, shapes) {
 function lowerDynReceiverMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(call, access))
         return null;
+    if (stdlibGlobalNameOf(lowerer, access.expression) !== null)
+        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);
+    const recvSymbol = recvTs.getSymbol();
+    if (recvSymbol && ["MapIterator", "SetIterator"].includes(recvSymbol.name) &&
+        lowerer.isStdlibSymbol(recvSymbol) &&
+        ["map", "filter", "take", "drop", "flatMap", "toArray", "forEach", "reduce", "some", "every", "find"].includes(access.name.text) &&
+        lowerer.isStdlibMember(access)) {
+        lowerer.noLowering(`collection iterator .${access.name.text}()`, call, "stored Map/Set iterators support .next() and iteration; iterator helper methods have no lowering");
+    }
     const arrayReceiver = lowerer.checker.isArrayType(recvTs);
     const anyArray = arrayReceiver &&
         ((lowerer.checker.getTypeArguments(recvTs)[0]?.flags ?? 0) &
@@ -5860,7 +5973,7 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
             !["call", "apply", "bind", "toString", "valueOf", "constructor"].includes(access.name.text) &&
             canBoxFuncIntoDyn(probed.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
             const loc = locOf(call);
-            const fnName = jsFuncNameOf(access.expression);
+            const fnName = jsFuncNameOf(access.expression, lowerer);
             const boxed = { kind: "dynFrom", value: probed, type: DYN, loc, ...(fnName !== null ? { fnName } : {}) };
             const local = lowerer.declareHiddenLocal("%callableReceiver", DYN);
             const receiver = { kind: "varRef", localId: local.id, type: DYN, loc };
@@ -5879,18 +5992,24 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
         }
         if (probed?.type.kind === "classval") {
             const info = lowerer.classes.get(probed.type.className);
-            if (info && (info.callableBase || hasRuntimeStatics(info)))
+            if (info)
                 return lowerStaticMethodCall(lowerer, call, access);
         }
-        if (probed?.type.kind !== "dyn")
-            return null;
-        recv = probed;
+        if (probed?.type.kind === "union" && isJsSourceFile(call.getSourceFile()) &&
+            lowerer.unions.get(probed.type.unionId)?.arms.every((arm) => isUnitType(arm) || arm.kind === "object" || arm.kind === "record" || arm.kind === "func") && lowerer.dynConvertible(probed.type)) {
+            recv = lowerer.coerceToExpected(probed, DYN);
+        }
+        else {
+            if (probed?.type.kind !== "dyn")
+                return null;
+            recv = probed;
+        }
     }
     // A factory may return a constructor more precise than its inferred
     // checker result. Runtime static members live on that constructor.
     if (recv.type.kind === "classval") {
         const info = lowerer.classes.get(recv.type.className);
-        if (info && (info.callableBase || hasRuntimeStatics(info)))
+        if (info)
             return lowerStaticMethodCall(lowerer, call, access);
     }
     // A checker-`any` receiver that already lowered to a real STRING (the
@@ -5906,6 +6025,25 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
     }
     if (recv.type.kind !== "dyn")
         return null;
+    if (access.name.text === "normalize" && call.arguments.length <= 1 && !call.arguments.some(ts.isSpreadElement)) {
+        const loc = locOf(call);
+        const hasArgument = call.arguments.length === 1;
+        const name = `%dyn.string.normalize:${hasArgument ? 1 : 0}`;
+        if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
+            const value = varRef("receiver", DYN, loc);
+            const argument = varRef("form", DYN, loc);
+            const form = { kind: "ternary", cond: { kind: "dynTest", value: argument, test: "undefined", type: BOOL, loc },
+                then: { kind: "strLit", value: "NFC", type: STRING, loc },
+                else_: { kind: "libCall", fn: "dyn.toStringCoerce", args: [argument], type: STRING, loc }, type: STRING, loc };
+            const result = { kind: "strIntrinsic", method: "normalize", receiver: { kind: "dynCheck", value, type: STRING, loc }, args: [form], type: STRING, loc };
+            lowerer.liftedFns.push({ name, params: [{ localId: "receiver", name: "receiver", type: DYN }, { localId: "form", name: "form", type: DYN }],
+                locals: [{ id: "receiver", name: "receiver", type: DYN, mutable: false }, { id: "form", name: "form", type: DYN, mutable: false }], returnType: DYN, loc,
+                body: [{ kind: "if", cond: { kind: "dynTest", value, test: "string", type: BOOL, loc }, then: [
+                            { kind: "return", value: { kind: "dynFrom", value: result, type: DYN, loc }, loc },
+                        ], else_: null, loc }, { kind: "return", value: { kind: "dynInvoke", recv: value, method: "normalize", calleeName: access.getText(), args: hasArgument ? [argument] : [], type: DYN, loc }, loc }] });
+        }
+        return { kind: "call", callee: name, args: [recv, call.arguments[0] ? lowerer.lowerExprExpecting(call.arguments[0], DYN) : dynUndefinedExpr(loc)], type: DYN, loc };
+    }
     if (lowerer.mapTypeOf(recvTs)?.kind === "classval") {
         return lowerStaticMethodCall(lowerer, call, access);
     }
@@ -5965,6 +6103,9 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
     // with the original receiver rather than a materialized property view.
     const callbackProperty = (() => {
         const prop = lowerer.checker.getPropertyOfType(recvTs, access.name.text);
+        const mapped = lowerer.mapTypeOf(recvTs);
+        if (mapped?.kind === "union" && lowerer.unions.get(mapped.unionId)?.arms.every((arm) => arm.kind === "object" && lowerer.classes.get(arm.className)?.fields.has(access.name.text)))
+            return true;
         return prop !== undefined && lowerer.checker.declarationsOf(prop).some((decl) => ts.isPropertyDeclaration(decl) || ts.isPropertySignature(decl));
     })();
     const dispatched = callbackProperty ? null : lowerDynDispatchMethodCall(lowerer, call, access, recv, arrayReceiver);
@@ -6002,18 +6143,24 @@ function lowerDynReceiverMethodCall(lowerer, call, access) {
         type: DYN,
         loc: locOf(access),
     };
+    const calleeLocal = lowerer.declareHiddenLocal("%dynCallCallee", DYN);
+    const callee = varRef(calleeLocal.id, DYN, loc);
+    const stmts = [
+        { kind: "varDecl", localId: receiverLocal.id, init: recv, loc },
+        { kind: "varDecl", localId: calleeLocal.id, init: member, loc },
+    ];
     if (call.arguments.some(ts.isSpreadElement)) {
-        const spread = lowerSpreadArgsCall(lowerer, call, member, loc);
+        const spread = lowerSpreadArgsCall(lowerer, call, callee, loc);
         if (spread?.kind === "dynCall")
             return { kind: "seqExpr",
-                stmts: [{ kind: "varDecl", localId: receiverLocal.id, init: recv, loc }],
+                stmts,
                 result: { ...spread, receiver }, type: DYN, loc };
         lowerer.unsupported("SC1090", call, "spread arguments in calls through 'unknown' values");
     }
     const args = call.arguments.map((a) => lowerer.lowerExprExpecting(a, DYN));
     return {
-        kind: "seqExpr", stmts: [{ kind: "varDecl", localId: receiverLocal.id, init: recv, loc }],
-        result: { kind: "dynCall", callee: member, receiver, calleeName: access.getText(), args, type: DYN, loc }, type: DYN, loc,
+        kind: "seqExpr", stmts,
+        result: { kind: "dynCall", callee, receiver, calleeName: access.getText(), args, type: DYN, loc }, type: DYN, loc,
     };
 }
 /** Prototype method names of the checked-dynamic tree-representable kinds (String, Array,
@@ -6041,6 +6188,7 @@ const DYN_PROTO_METHOD_NAMES = new Set([
  * is-not-a-function where the kind's prototype lacks the name, and
  * fences LOUDLY on real-but-unimplemented pairs. */
 const DYN_DISPATCH_METHODS = new Set([
+    "toFixed", "toExponential",
     "segment", "containing", "resolvedOptions", "test", "exec",
     "apply", "bind", "call",
     "push", "pop", "shift", "unshift", "slice", "at",
@@ -6539,6 +6687,15 @@ function lowerPrimitiveProtoCall(lowerer, call, recv, name, memberSym) {
     if (!lowerer.isStdlibSymbol(memberSym))
         return null;
     const recvKind = lowerer.mapTypeOf(lowerer.typeOf(recv))?.kind;
+    if ((name === "toFixed" || name === "toExponential") && call.arguments.length <= 1 &&
+        !call.arguments.some(ts.isSpreadElement) && isJsSourceFile(call.getSourceFile())) {
+        const operand = lowerer.lowerExpr(recv);
+        if (operand.type.kind === "dyn" || operand.type.kind === "union" && lowerer.dynConvertible(operand.type))
+            return {
+                kind: "dynInvoke", recv: lowerer.coerceToExpected(operand, DYN), method: name, calleeName: `${recv.getText()}.${name}`,
+                args: call.arguments.map((argument) => lowerer.lowerExprExpecting(argument, DYN)), type: DYN, loc: locOf(call),
+            };
+    }
     if (recvKind !== "f64" && recvKind !== "bool" && recvKind !== "string")
         return null;
     const loc = locOf(call);
@@ -7019,6 +7176,17 @@ export function lowerNestedFunctionDecl(lowerer, stmt) {
         throw new InternalCompilerError("lowerer bug: nested function declaration has no active statement list");
     }
     const init = lowerer.lowerLambda(stmt);
+    // Body inference may settle a JS return differently from the initial
+    // checker signature. Publish that same ABI on the hoisted binding and
+    // every mutable capture of it before callers are lowered.
+    if (init.type.kind === "func" && !typeEquals(local.type, init.type)) {
+        local.type = init.type;
+        for (const fn of lowerer.liftedFns)
+            for (const capture of fn.captures ?? []) {
+                if (capture.localId === local.id)
+                    capture.type = init.type;
+            }
+    }
     return { kind: "assign", localId: local.id, value: init, loc: locOf(stmt) };
 }
 /** Signature checks + param shapes + IR func type for any lambda-like
@@ -7183,6 +7351,13 @@ export function lowerLambda(lowerer, node) {
     const signature = lowerer.lambdaSignature(node);
     const { shapes } = signature;
     let { funcType } = signature;
+    // Reflected JS methods receive the caller's actual `this`, which may
+    // be a Proxy or a descriptor-created object rather than the class.
+    // Fluent methods must return that receiver without a class cast.
+    if (ts.isMethodDeclaration(node) && isJsSourceFile(node.getSourceFile()) &&
+        !node.type && !node.asteriskToken && !hasExplicitJsDocReturn(node) && returnsOnlyThis(node)) {
+        funcType = { ...funcType, ret: funcType.ret.kind === "promise" ? { ...funcType.ret, inner: DYN } : DYN };
+    }
     // A lambda IS a value: the completed-ABI rule applies at birth. The
     // contextual (target) type decides — `(x?: number) => void` may flow
     // into a slot annotated `(x: number | undefined) => void` (same ABI
@@ -7792,7 +7967,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                     value: {
                         kind: "dynCall",
                         callee: { kind: "varRef", localId: cbLocal.id, type: DYN, loc },
-                        calleeName: jsFuncNameOf(call.arguments[0]) ?? "onFulfilled",
+                        calleeName: jsFuncNameOf(call.arguments[0], lowerer) ?? "onFulfilled",
                         args: handlerArgs,
                         type: DYN,
                         loc,
@@ -7825,7 +8000,8 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             lowerer.unsupported("SC1090", call.arguments[0], "then handlers with more than one parameter (the two-argument onRejected form has no lowering — chain .catch(...) instead)");
         }
         const param = cb.type.params[0];
-        if (param !== undefined && !typeEquals(param, inner) && !(inner.kind === "void" && param.kind === "dyn")) {
+        if (param !== undefined && !typeEquals(param, inner) &&
+            !(param.kind === "dyn" && (inner.kind === "void" || lowerer.dynConvertible(inner)))) {
             lowerer.unsupported("SC1090", call.arguments[0], `then handlers whose parameter is not the settled value's type (expected '${lowerer.fmt(inner)}', got '${lowerer.fmt(param)}')`);
         }
         const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
@@ -7855,7 +8031,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             if (param !== undefined && inner.kind !== "void") {
                 const vLocal = lowerer.declareHiddenLocal("v", inner);
                 body.push({ kind: "varDecl", localId: vLocal.id, init: awaitE, loc });
-                handlerArgs = [{ kind: "varRef", localId: vLocal.id, type: inner, loc }];
+                handlerArgs = [lowerer.coerceToExpected({ kind: "varRef", localId: vLocal.id, type: inner, loc }, param)];
             }
             else {
                 body.push({ kind: "exprStmt", expr: awaitE, loc });
@@ -7916,6 +8092,14 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
     }
     if (member === "finally") {
         const cb = lowerer.lowerExpr(call.arguments[0]);
+        if (lowerer.dynConvertible(promT) && lowerer.dynConvertible(cb.type)) {
+            const result = {
+                kind: "dynInvoke", recv: lowerer.coerceToExpected(receiver, DYN),
+                method: "finally", calleeName: access.getText(),
+                args: [lowerer.coerceToExpected(cb, DYN)], type: DYN, loc,
+            };
+            return lowerer.coerceToExpected(result, promT);
+        }
         if (cb.type.kind !== "func" || cb.type.params.length !== 0 || cb.type.ret.kind !== "void") {
             lowerer.unsupported("SC1090", call.arguments[0], "finally callbacks with parameters or a return value (use () => { ... })");
         }
@@ -7992,7 +8176,8 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
     // receiver, passes fulfillments through as dyn, and on rejection
     // calls the boxed handler with caughtToDyn's identity-preserving
     // snapshot (the dyn-then desugar's catch twin).
-    if (member === "catch" && inner.kind === "dyn") {
+    if (member === "catch" && (inner.kind === "dyn" || isJsSourceFile(call.getSourceFile()) &&
+        (inner.kind === "void" || lowerer.dynConvertible(inner)))) {
         let cb = lowerer.lowerExpr(call.arguments[0]);
         if (cb.type.kind === "func" &&
             canBoxFuncIntoDyn(cb.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
@@ -8009,20 +8194,11 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                 const pLocal = lowerer.declareHiddenLocal("p", promT);
                 const cbLocal = lowerer.declareHiddenLocal("cb", DYN);
                 const eLocal = lowerer.declareHiddenLocal("e", CAUGHT);
-                const vLocal = lowerer.declareHiddenLocal("v", DYN);
+                const vLocal = inner.kind === "void" ? null : lowerer.declareHiddenLocal("v", inner);
+                const awaited = { kind: "awaitExpr", value: { kind: "varRef", localId: pLocal.id, type: promT, loc }, type: inner, loc };
                 const tryBody = [
-                    {
-                        kind: "varDecl",
-                        localId: vLocal.id,
-                        init: {
-                            kind: "awaitExpr",
-                            value: { kind: "varRef", localId: pLocal.id, type: promT, loc },
-                            type: DYN,
-                            loc,
-                        },
-                        loc,
-                    },
-                    { kind: "return", value: { kind: "varRef", localId: vLocal.id, type: DYN, loc }, loc },
+                    vLocal ? { kind: "varDecl", localId: vLocal.id, init: awaited, loc } : { kind: "exprStmt", expr: awaited, loc },
+                    { kind: "return", value: vLocal ? lowerer.coerceToExpected(varRef(vLocal.id, inner, loc), DYN) : dynUndefinedExpr(loc), loc },
                 ];
                 const catchBody = [
                     {
@@ -8030,7 +8206,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                         value: {
                             kind: "dynCall",
                             callee: { kind: "varRef", localId: cbLocal.id, type: DYN, loc },
-                            calleeName: jsFuncNameOf(call.arguments[0]) ?? "onRejected",
+                            calleeName: jsFuncNameOf(call.arguments[0], lowerer) ?? "onRejected",
                             args: [
                                 {
                                     kind: "caughtToDyn",
@@ -8833,7 +9009,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
         !call.arguments.some(ts.isSpreadElement) && !lowerer.dynamic) {
         let object = lowerer.lowerExpr(call.arguments[0]);
         if (object.type.kind === "func") {
-            const fnName = jsFuncNameOf(call.arguments[0]);
+            const fnName = jsFuncNameOf(call.arguments[0], lowerer);
             object = { kind: "dynFrom", value: object, type: DYN, loc: locOf(call),
                 ...(fnName !== null ? { fnName } : {}) };
         }
@@ -8841,8 +9017,15 @@ function lowerObjectStaticCall(lowerer, call, access) {
             object = lowerer.coerceInto(call.arguments[0], object, DYN);
         if (object.type.kind === "dyn") {
             const loc = locOf(call);
-            if (member === "getPrototypeOf")
-                return { kind: "libCall", fn: "dyn.getPrototype", args: [object], type: DYN, loc };
+            if (member === "getPrototypeOf") {
+                let parent = call.parent;
+                while (parent && ts.isParenthesizedExpression(parent))
+                    parent = parent.parent;
+                const identityOnly = !!parent && ts.isBinaryExpression(parent) &&
+                    [ts.SyntaxKind.EqualsEqualsEqualsToken, ts.SyntaxKind.ExclamationEqualsEqualsToken].includes(parent.operatorToken.kind);
+                return { kind: "libCall", fn: "dyn.getPrototype", args: [object], type: DYN, loc,
+                    ...(identityOnly ? { prototypeIdentityOnly: true } : {}) };
+            }
             const prototype = lowerer.lowerExprExpecting(call.arguments[1], DYN);
             if (prototype.type.kind === "dyn")
                 return { kind: "libCall", fn: "dyn.setPrototype", args: [object, prototype], type: DYN, loc };
@@ -9024,7 +9207,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
         if (isJsSourceFile(call.getSourceFile()) && call.arguments.length > 0 && !call.arguments.some(ts.isSpreadElement)) {
             const target = tryLowerExpression(lowerer, call.arguments[0]);
             if (target && ((target.type.kind === "func" && lowerer.dynConvertible(target.type)) ||
-                (target.type.kind === "object" && lowerer.errorHierarchyClassOf(target.type.className)))) {
+                (target.type.kind === "object" && lowerer.dynConvertible(target.type)))) {
                 const loc = locOf(call);
                 return { kind: "libCall", fn: "dyn.assignAll", args: [lowerer.coerceToExpected(target, DYN),
                         { kind: "dynArrLit", elems: call.arguments.slice(1).map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc },
@@ -9226,7 +9409,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
             target = lowerer.coerceToExpected(target, DYN);
         }
         if (target?.type.kind === "func" && lowerer.dynConvertible(target.type)) {
-            const fnName = jsFuncNameOf(call.arguments[0]);
+            const fnName = jsFuncNameOf(call.arguments[0], lowerer);
             target = { kind: "dynFrom", value: target, type: DYN, loc: locOf(call.arguments[0]), ...(fnName !== null ? { fnName } : {}) };
         }
         const descriptorPrimitive = member === "getOwnPropertyDescriptor" && target &&
@@ -9255,6 +9438,9 @@ function lowerObjectStaticCall(lowerer, call, access) {
     // static shapes have no property table to extend.
     if (member === "defineProperties" && call.arguments.length === 2 &&
         !call.arguments.some((a) => ts.isSpreadElement(a))) {
+        const prototype = lowerClassPrototypeDescriptors(lowerer, call, member);
+        if (prototype)
+            return prototype;
         let target = tryLowerExpression(lowerer, call.arguments[0]);
         if (target) {
             const native = lowerClassDataDescriptor(lowerer, call, member, target);
@@ -9267,7 +9453,7 @@ function lowerObjectStaticCall(lowerer, call, access) {
         // wrapper returned later reads the same table.
         if (target && target.type.kind === "func" &&
             canBoxFuncIntoDyn(target.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
-            const fnName = jsFuncNameOf(call.arguments[0]);
+            const fnName = jsFuncNameOf(call.arguments[0], lowerer);
             target = { kind: "dynFrom", value: target, type: DYN, loc: locOf(call.arguments[0]), ...(fnName !== null ? { fnName } : {}) };
         }
         if (target && isUnitType(target.type)) {
@@ -9322,7 +9508,8 @@ function lowerObjectStaticCall(lowerer, call, access) {
         let inner = argNode;
         while (ts.isParenthesizedExpression(inner) || ts.isAsExpression(inner))
             inner = inner.expression;
-        const value = lowerer.lowerExpr(argNode);
+        const value = isJsSourceFile(call.getSourceFile()) && (ts.isObjectLiteralExpression(inner) || ts.isArrayLiteralExpression(inner))
+            ? lowerer.lowerExprExpecting(argNode, DYN) : lowerer.lowerExpr(argNode);
         if (value.type.kind === "dyn")
             return { kind: "libCall", fn: "dyn.freeze", args: [value], type: DYN, loc: locOf(call) };
         if (ts.isObjectLiteralExpression(inner) || ts.isArrayLiteralExpression(inner)) {
@@ -9458,14 +9645,11 @@ function lowerObjectStaticCall(lowerer, call, access) {
         }
     }
     let argIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
-    // JS: an unmappable CHECKER type over a value that lowered to a real
-    // record (the narrowed export-table literal) — the lowered value's
-    // shape is the honest dispatch key, exactly the identity-Set stance.
-    if (argIr === null && isJsSourceFile(argNode.getSourceFile())) {
-        const probed = tryLowerExpression(lowerer, argNode);
-        if (probed?.type.kind === "record")
-            argIr = probed.type;
-    }
+    // Inferred records can carry runtime-optional index values that the
+    // checker omits (named regex captures). Enumerate the represented shape.
+    const represented = tryLowerExpression(lowerer, argNode);
+    if (represented?.type.kind === "record")
+        argIr = represented.type;
     if (argIr?.kind !== "record")
         return null; // Maps, classes, arrays → the SC2020 fence
     const shape = lowerer.shapes.get(argIr.shapeId);
@@ -9857,6 +10041,13 @@ export function lowerRecordFieldCall(lowerer, call, access) {
         return { kind: "callValue", callee, args, type: callee.type.ret, loc: locOf(call) };
     }
     const target = lowerer.fieldTarget(access);
+    const loc = locOf(call);
+    const receiverLocal = target && isJsSourceFile(call.getSourceFile())
+        ? lowerer.declareHiddenLocal("%callReceiver", target.obj.type) : null;
+    const init = target && receiverLocal
+        ? { kind: "varDecl", localId: receiverLocal.id, init: target.obj, loc } : null;
+    if (target && receiverLocal)
+        target.obj = varRef(receiverLocal.id, receiverLocal.type, loc);
     let callee = target ? lowerer.fieldGetExpr(target, locOf(access), access) : null;
     if (!callee)
         return null;
@@ -9865,10 +10056,24 @@ export function lowerRecordFieldCall(lowerer, call, access) {
     // `.bold` (the chalk shape).
     if (callee.type.kind === "record")
         callee = lowerer.hybridCallUnwrap(callee);
+    // Inferred JavaScript option records can retain checked callables in
+    // fields even when the checker only describes those members as any.
+    if (callee.type.kind === "dyn" && isJsSourceFile(call.getSourceFile())) {
+        const receiver = target && receiverLocal ? lowerer.coerceToExpected(target.obj, DYN) : undefined;
+        const spread = call.arguments.some(ts.isSpreadElement) ? lowerSpreadArgsCall(lowerer, call, callee, loc) : null;
+        if (spread && spread.kind !== "dynCall")
+            lowerer.unsupported("SC1090", call, "checked record property call spread arguments");
+        const result = spread ? (receiver ? { ...spread, receiver } : spread) : {
+            kind: "dynCall", callee, ...(receiver ? { receiver } : {}), calleeName: access.getText(),
+            args: call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc,
+        };
+        return init ? { kind: "seqExpr", stmts: [init], result, type: result.type, loc } : result;
+    }
     if (callee.type.kind !== "func")
         lowerer.badType(access, lowerer.typeOf(access));
     const args = completeFuncValueArgs(lowerer, call, callee.type, locOf(call));
-    return { kind: "callValue", callee, args, type: callee.type.ret, loc: locOf(call) };
+    const result = { kind: "callValue", callee, ...(target && receiverLocal ? { receiver: lowerer.coerceToExpected(target.obj, DYN) } : {}), args, type: callee.type.ret, loc };
+    return init ? { kind: "seqExpr", stmts: [init], result, type: result.type, loc } : result;
 }
 /** The function-like node behind an object-literal generic-method member:
    * the MethodDeclaration itself (`{ m<T>(x: T) {...} }`) or a generic
@@ -10526,7 +10731,8 @@ export function requireObjLitGenericReceiver(lowerer, blame, recvExpr, literal,
    * direct `call` of the instance with the receiver unevaluated. Claims
    * every call whose member is generic-callable — lowering it or fencing
    * with a named message. */
-/** URL.revokeObjectURL() with NO argument: Node's ERR_MISSING_ARGS
+/** The URL factories use the constructor's conversion order and parser.
+ * URL.revokeObjectURL() with NO argument: Node's ERR_MISSING_ARGS
  * throws before the registry lookup, so the zero-argument contract is
  * exact without any blob machinery. The one-argument form (Node's
  * silent no-op for unregistered ids) and createObjectURL keep their
@@ -10534,12 +10740,15 @@ export function requireObjLitGenericReceiver(lowerer, blame, recvExpr, literal,
 function lowerUrlStaticCall(lowerer, call, callee) {
     if (!ts.isPropertyAccessExpression(callee) || callee.questionDotToken !== undefined)
         return null;
-    if (!ts.isIdentifier(callee.expression) || callee.expression.text !== "URL")
-        return null;
-    if (callee.name.text !== "revokeObjectURL" || call.arguments.length !== 0)
+    if (!ts.isIdentifier(callee.expression))
         return null;
     const sym = lowerer.resolveValueSymbol(callee.expression);
-    if (!sym || !lowerer.isStdlibSymbol(sym))
+    if (!sym || !lowerer.isStdlibSymbol(sym) || sym.name !== "URL")
+        return null;
+    if (callee.name.text === "canParse" || callee.name.text === "parse") {
+        return lowerUrlFactory(lowerer, call, callee.name.text);
+    }
+    if (callee.name.text !== "revokeObjectURL" || call.arguments.length !== 0)
         return null;
     return nodeThrowExpr(1, "ERR_MISSING_ARGS", 'The "url" argument must be specified', VOID, locOf(call));
 }
@@ -10820,9 +11029,11 @@ export function lowerObjectMethodCall(lowerer, call, access) {
     // type still belongs to the unspecialized body (plane.normal.dot()).
     // Use the lowered receiver's representation and retain its evaluation.
     const probe = mappedReceiver?.kind !== "object" && (lowerer.implicitParamTypes !== null || ts.isNewExpression(access.expression) ||
-        isJsSourceFile(call.getSourceFile()) && ts.isCallExpression(access.expression))
-        ? tryLowerExpression(lowerer, access.expression) : null;
-    const specializedReceiver = probe?.type.kind === "object" ? probe : null;
+        isJsSourceFile(call.getSourceFile()))
+        ? ts.isNewExpression(access.expression) ? lowerer.lowerExpr(access.expression) : tryLowerExpression(lowerer, access.expression)
+        : null;
+    const specializedReceiver = probe?.type.kind === "object" || probe?.type.kind === "union" &&
+        lowerer.unions.get(probe.type.unionId)?.arms.some((arm) => arm.kind === "object") ? probe : null;
     if (specializedReceiver)
         mappedReceiver = specializedReceiver.type;
     if (mappedReceiver?.kind === "union") {
@@ -10833,8 +11044,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         const arms = lowerer.unions.get(mappedReceiver.unionId)?.arms;
         if (isJsSourceFile(call.getSourceFile()) && arms?.every((arm) => arm.kind === "object" &&
             !lowerer.classes.get(arm.className)?.def.runtime) && lowerer.dynConvertible(mappedReceiver)) {
-            const receiver = lowerer.coerceInto(access.expression, lowerer.lowerExpr(access.expression), DYN);
-            return lowerDynDispatchMethodCall(lowerer, call, access, receiver, false);
+            return lowerDynReceiverMethodCall(lowerer, call, access);
         }
     }
     const receiverIr = mappedReceiver?.kind === "object"
@@ -10982,7 +11192,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         const fallback = virtual
             ? { kind: "virtualCall", className: info.def.name, method, args: [lowerer.upcastTo(value, info.def.name), ...args], type: found.sig.ret, loc }
             : { kind: "call", callee: `%${found.declarer.def.name}.${method}`, args: [lowerer.upcastTo(value, found.declarer.def.name), ...args], type: found.sig.ret, loc };
-        const result = classCallbackCall(lowerer, value, method, call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), fallback, loc);
+        const result = classCallbackCall(lowerer, value, method, call.arguments.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), fallback, loc, access.getText());
         return { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: local.id, init: receiver, loc }], result, type: result.type, loc };
     }
     if (found.declarer.builtinError) {