@scriptc/compiler 0.1.4 → 0.1.6

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

@@ -6,18 +6,18 @@ import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
 import { lowerGenMethodCall } from "./lower-generators.js";
 import { BIGINT_T, BOOL, CAUGHT, DYN, F64, JSVAL, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, canMarshalTypedFuncIntoIsland, ffiClassType, ffiSourceParamTypes, funcOf, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
-import { isJsSourceFile, locOf } from "../program.js";
+import { isJsSourceFile, isNodeEsmFile, locOf } from "../program.js";
 import { genResultRecord, isGenericCallableMemberType, typeKey } from "../type-mapper.js";
 import { PoisonError, dynFallbackType, dynUndefinedExpr, importCallHandleType, jsFuncNameOf, newFnCtx, nodeThrowExpr, staticImportNamespaceType } from "./lowerer.js";
 import { enforceLibBoundary } from "./lib-boundary.js";
-import { NARROW_FIRST, builtinFenceHintOf, builtinModuleFnOf } from "./surfaces.js";
+import { NARROW_FIRST, STRING_INDEX_METHODS, STR_METHODS, builtinFenceHintOf, builtinModuleFnOf } from "./surfaces.js";
 import { ffiBindingDiag, ffiSignatureDiag, libCallbackDiag, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
 import { mixinFnShapeOf } from "./lower-mixins.js";
-import { dynStringReceiver, lowerArrayFromCall, lowerDynArrayFilterCall, lowerDynArrayFlatMapCall, lowerGroupByStaticCall, lowerIteratorHelperCall, lowerObjectAssignIndexShape, lowerObjectFromEntriesCall, lowerObjectIterOverIndexShape, lowerTupleReadMethodCall } from "./lower-containers.js";
+import { dynStringReceiver, lowerArrayConstructor, lowerArrayFromCall, lowerArrayOfCall, lowerDynArrayFilterCall, lowerDynArrayFlatMapCall, lowerGroupByStaticCall, lowerIteratorHelperCall, lowerObjectAssignIndexShape, lowerObjectFromEntriesCall, lowerObjectIterOverIndexShape, lowerTupleReadMethodCall } from "./lower-containers.js";
 import { bufEncoding } from "./containers/bytes.js";
-import { lowerRegexMethodCall, lowerStringMethodCall } from "./containers/string-and-regexp.js";
+import { lowerRegexMethodCall, lowerStringIndexCall, lowerStringMethodCall, lowerStringPaddingCall, lowerStringSplitCall } from "./containers/string-and-regexp.js";
 import { lowerChildStreamMethodCall, lowerChildWriterMethodCall, lowerCreateRequireCall, lowerCryptoHashMethodCall, lowerDirentMethodCall, lowerFileHandleMethodCall, lowerImportMetaResolveCall, lowerNodeModuleCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerRequireResolveCall, lowerWatcherMethodCall } from "./lower-builtins.js";
-import { lowerAbsenceProbe, lowerPromiseAllTupleCall, lowerPromiseRejectCall, templateRawTextOf } from "./lower-exprs.js";
+import { lowerAbsenceProbe, lowerPromiseAllTupleCall, lowerPromiseRejectCall, stringWrapperToString, templateRawTextOf } from "./lower-exprs.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { httpClientFnBindingOf, isStreamUndefCallExpr, lowerCompatReqStreamOptionalCall, lowerHttpClientFnCall } from "./lower-server.js";
@@ -32,6 +32,7 @@ import { npmStaticPackageOfPath } from "../npm-static.js";
 import { countedFor, varRef } from "../../ir/build.js";
 import { rejectStaticThis } from "./static-this.js";
 import { fenceNodeModuleMutationCall, lowerRequireCacheKeys } from "./lower-node-module.js";
+import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, positionNumber } from "./optional-arguments.js";
 /** The one func-type projection of completed parameter shapes. Typed rest
  * parameters keep their packed array as the trailing native ABI slot and
  * mark the value variadic so indirect call sites run completeArgs before
@@ -40,12 +41,14 @@ import { fenceNodeModuleMutationCall, lowerRequireCacheKeys } from "./lower-node
 export function funcTypeFromParamShapes(shapes, ret) {
     const typedRest = shapes.some((shape) => shape.mode === "rest");
     const dynRest = shapes.some((shape) => shape.mode === "dynRest");
+    const argumentsAll = shapes.some((shape) => shape.mode === "arguments");
     const islandRest = shapes.some((shape) => shape.mode === "islandRest");
     return {
         kind: "func",
-        params: shapes.filter((shape) => shape.mode !== "dynRest").map((shape) => shape.type),
+        params: shapes.filter((shape) => shape.mode !== "dynRest" && shape.mode !== "arguments").map((shape) => shape.type),
         ret,
-        ...(typedRest || dynRest || islandRest ? { rest: true } : {}),
+        ...(typedRest || dynRest || islandRest || argumentsAll ? { rest: true } : {}),
+        ...(argumentsAll ? { argumentsAll: true } : {}),
         ...(typedRest
             ? { restAbi: "typed" }
             : islandRest
@@ -382,8 +385,42 @@ leading) {
             });
         });
     }
-    const restAt = shapes.findIndex((s) => s.mode === "rest" || s.mode === "dynRest" || s.mode === "islandRest");
+    const restAt = shapes.findIndex((s) => s.mode === "rest" || s.mode === "dynRest" || s.mode === "islandRest" || s.mode === "arguments");
     const positional = restAt >= 0 ? shapes.slice(0, restAt) : [...shapes];
+    if (restAt >= 0 && shapes[restAt].mode === "arguments") {
+        // JS `arguments` contains every supplied value, including fixed
+        // parameters. Store each call expression once, in source order, so
+        // both the native parameter slots and the full array read it.
+        const stmts = [];
+        const passed = sources.map((source, i) => {
+            if (!isIr(source) && ts.isSpreadElement(source)) {
+                lowerer.unsupported("SC1090", source, "spread arguments into fixed parameter positions (a spread can only fill a rest parameter)");
+            }
+            const slotType = i < restAt ? positional[i].type : DYN;
+            const value = isIr(source)
+                ? lowerer.coerceInto(blame, source.ir, slotType)
+                : lowerer.lowerExprExpecting(source, slotType);
+            const saved = lowerer.declareHiddenLocal("%callArg", slotType);
+            stmts.push({ kind: "varDecl", localId: saved.id, init: value, loc: value.loc });
+            return { kind: "varRef", localId: saved.id, type: slotType, loc: value.loc };
+        });
+        const fixed = positional.map((shape, i) => {
+            if (i < passed.length)
+                return passed[i];
+            if (shape.mode === "omittable")
+                return shape.callDefault ?? lowerer.undefinedArgFor(shape.type, loc, blame);
+            if (shape.type.kind === "dyn")
+                return { kind: "dynFrom", value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: DYN, loc };
+            lowerer.unsupported("SC1090", blame, "this call form");
+        });
+        const elems = passed.map((value) => lowerer.coerceInto(blame, value, DYN));
+        const full = { kind: "dynArrLit", elems, type: DYN, loc };
+        const out = [...fixed, full];
+        if (stmts.length > 0) {
+            out[0] = { kind: "seqExpr", stmts, result: out[0], type: out[0].type, loc };
+        }
+        return out;
+    }
     const out = positional.map((shape, i) => {
         const src = sources[i];
         if (isIr(src))
@@ -617,6 +654,7 @@ export function requireExactArityValue(lowerer, blame, contextual, shapes, funcT
     // tier's undefined (omittedArgFor).
     if (shapes.every((s) => s.mode === "required" ||
         s.mode === "dynRest" ||
+        s.mode === "arguments" ||
         s.mode === "islandRest" ||
         (s.mode === "omittable" && (s.type.kind === "dyn" || s.type.kind === "jsval")))) {
         return;
@@ -915,18 +953,16 @@ export function collectSignatureInner(lowerer, decl) {
         }
     }
     const params = lowerer.paramShapes(decl.parameters);
-    // The VARIADIC `arguments` form on a DECLARED function: same rule as
-    // lambdas (lambdaSignature) — zero declared params, the body reads
-    // `arguments`, a synthetic trailing dynRest shape carries the call's
-    // arguments (completeArgs packs direct calls; the boxed thunk packs
-    // indirect ones; lowerFunction declares the `arguments` local).
-    if (!params.some((sh) => sh.mode === "dynRest") &&
+    // A declared function reading `arguments` receives a hidden dyn array.
+    // The zero-parameter form uses the existing rest pack; named parameters
+    // use the full argument pack for both direct and boxed calls.
+    if (!params.some((sh) => sh.mode === "rest" || sh.mode === "dynRest" || sh.mode === "islandRest") &&
         isJsSourceFile(decl.getSourceFile()) &&
         bodyReadsArguments(decl)) {
-        if (decl.parameters.length > 0) {
-            lowerer.unsupported("SC1090", decl, "'arguments' in functions with declared parameters (use a rest parameter: (...args))");
+        if (decl.parameters.length > 0 && !isNodeEsmFile(decl.getSourceFile())) {
+            lowerer.unsupported("SC1090", decl, "parameterized 'arguments' outside an ES module (sloppy-mode parameter aliases)");
         }
-        params.push({ type: DYN, mode: "dynRest" });
+        params.push({ type: DYN, mode: decl.parameters.length > 0 ? "arguments" : "dynRest" });
     }
     const nameBlame = decl.name ?? decl;
     const returnType = lowerer.declaredReturnType(decl, nameBlame);
@@ -3339,13 +3375,12 @@ export function lowerCall(lowerer, expr) {
     // String(x) is exactly the template-literal ToString, Boolean(x) is
     // exactly the condition ToBoolean (union arms included), Number(x) is
     // ToNumber where it lowers exactly: numbers pass through, booleans
-    // become 1/0, and strings run the runtime's ECMA-exact
-    // StringToNumber (num.fromString — the full StringNumericLiteral
-    // grammar, scr_string.c). Other argument types (unions included —
-    // narrow first) keep the fence.
+    // become 1/0, null becomes 0, and undefined becomes NaN. Strings use
+    // the runtime's StringToNumber parser (num.fromString — the full
+    // StringNumericLiteral grammar in scr_string.c).
     // Provenance-checked like setTimeout; zero-arg forms are the JS
-    // constants ("", false, 0). `new String(...)` (wrapper objects) stays
-    // on the SC2020 fence.
+    // constants ("", false, 0). Wrapper objects stay fenced except where
+    // the receiver is immediately converted by a direct String method call.
     if (ts.isIdentifier(expr.expression) &&
         expr.expression.text === "BigInt" &&
         lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
@@ -3406,33 +3441,11 @@ export function lowerCall(lowerer, expr) {
         // bool) that a value lowering of the `&&` would fence on.
         if (name === "Boolean")
             return lowerer.lowerCondition(argNode);
+        if (name === "Number")
+            return lowerNumberConstructorValue(lowerer, argNode, loc);
         const arg = lowerer.lowerExpr(argNode);
         if (name === "String")
             return lowerer.ensureString(arg, argNode);
-        if (name === "Number" && arg.type.kind === "bigint") {
-            return { kind: "libCall", fn: "bigint.toF64", args: [arg], type: F64, loc };
-        }
-        if (arg.type.kind === "f64")
-            return arg;
-        if (arg.type.kind === "bool") {
-            return {
-                kind: "ternary",
-                cond: arg,
-                then: { kind: "numLit", value: 1, type: F64, loc },
-                else_: { kind: "numLit", value: 0, type: F64, loc },
-                type: F64,
-                loc,
-            };
-        }
-        if (arg.type.kind === "string") {
-            return { kind: "libCall", fn: "num.fromString", args: [arg], type: F64, loc };
-        }
-        const optionalNumber = lowerOptionalStringNumber(lowerer, arg, loc);
-        if (optionalNumber)
-            return optionalNumber;
-        lowerer.noLowering(`Number of ${lowerer.fmt(arg.type)} values`, argNode, arg.type.kind === "union"
-            ? "numbers, booleans, and strings lower (the full ToNumber string grammar included) — narrow the union first"
-            : undefined);
     }
     // __island_eval: the internal island testing hook (eval in the embedded
     // engine, String(result) back). Provenance-checked like setTimeout.
@@ -3568,6 +3581,9 @@ export function lowerCall(lowerer, expr) {
     // supported form is fenced here per site. Members with no lowering at
     // all (fs.watch, os.cpus, ...) fence with the module-qualified name.
     if (ts.isIdentifier(expr.expression)) {
+        if (expr.expression.text === "Array" && lowerer.isStdlibGlobal(expr.expression, "Array")) {
+            return lowerArrayConstructor(lowerer, expr, expr.arguments);
+        }
         // A call through a compile-time util.promisify projection. execFile
         // keeps its custom result helper; ordinary builtins route through
         // their existing promise-module lowering.
@@ -4175,11 +4191,14 @@ export function lowerCall(lowerer, expr) {
             // TestContext surface (t.test/t.skip/t.diagnostic), t.assert.*.
             lowerer.lowerTestMethodCall(expr, expr.expression) ??
             lowerer.lowerTimeoutMethodCall(expr, expr.expression) ??
+            lowerObjectOwnPrototypeCall(lowerer, expr, expr.expression) ??
+            lowerObjectPrototypeCall(lowerer, expr, expr.expression) ??
+            lowerStringPrototypeCall(lowerer, expr, expr.expression) ??
             lowerStringMethodCallWithOptionalArgs(lowerer, expr, expr.expression) ??
             // Typed-array/Buffer receivers and the Buffer statics — before the
             // island path (bytes never cross the boundary).
             lowerer.lowerBytesMethodCall(expr, expr.expression) ??
-            lowerBufferStaticCallWithOptionalArg(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) ??
@@ -4203,6 +4222,7 @@ export function lowerCall(lowerer, expr) {
             // hasOwnProperty on a program class CONSTRUCTOR — own statics are
             // compile-time-known, so a literal key folds to a constant.
             lowerClassHasOwnPropertyCall(lowerer, expr, expr.expression) ??
+            lowerObjectOwnMethodCall(lowerer, expr, expr.expression) ??
             // Response constructor-object operations are unsupported in both
             // tiers. Keep their SC2020 inventory contract ahead of the island
             // and generic-call fallbacks (Response.json otherwise reports the
@@ -4243,6 +4263,7 @@ export function lowerCall(lowerer, expr) {
             lowerObjectStaticCall(lowerer, expr, expr.expression) ??
             lowerObjectFromEntriesCall(lowerer, expr, expr.expression) ??
             lowerArrayFromCall(lowerer, expr, expr.expression) ??
+            lowerArrayOfCall(lowerer, expr, expr.expression) ??
             lowerer.lowerArrayMethodCall(expr, expr.expression) ??
             // Read-only array methods (slice/map) on TUPLE receivers — the
             // positions snapshot into a fresh array (the for-of stance).
@@ -4454,22 +4475,29 @@ function lowerRegexMethodCallWithOptionalArg(lowerer, call, access) {
 function optionalCallValue(lowerer, node) {
     return lowerer.runtimeOptionalIdentifierValue(node)?.value ?? lowerAbsenceProbe(lowerer, node);
 }
-function lowerBufferStaticCallWithOptionalArg(lowerer, call, access) {
+function lowerBufferStaticCallWithNarrowedArg(lowerer, call, access) {
     const lowered = lowerer.lowerBufferStaticCall(call, access);
     if (lowered?.kind !== "bytesNew" || !lowered.source || lowered.source.type.kind !== "union")
         return lowered;
-    const present = lowerer.stripUndefinedArm(lowered.source.type);
-    const validSource = (present.kind === "array" && present.elem.kind === "f64") ||
-        (present.kind === "bytes" && present.elem === "u8");
-    if (!validSource)
-        return lowered;
-    const helper = lowerer.narrowedArmHelper(lowered.source.type.unionId, present, lowered.source.loc);
-    return helper
-        ? {
-            ...lowered,
-            source: { kind: "call", callee: helper, args: [lowered.source], type: present, loc: lowered.source.loc },
-        }
-        : lowered;
+    // A callback can store a wider union than the checker sees at this use
+    // (including an added undefined arm). Extract the exact arm proven by
+    // control-flow narrowing, not merely the union with undefined removed.
+    const narrowed = lowerer.mapTypeOf(lowerer.typeOf(call.arguments[0]));
+    if (!narrowed ||
+        !(narrowed.kind === "f64" ||
+            (narrowed.kind === "array" && narrowed.elem.kind === "f64") ||
+            (narrowed.kind === "bytes" && narrowed.elem === "u8")) ||
+        lowerer.armTag(lowered.source.type.unionId, narrowed) < 0) {
+        lowerer.unsupported("SC1090", call.arguments[0], "a Buffer constructor argument whose narrowed type is not a stored source arm");
+    }
+    const helper = lowerer.narrowedArmHelper(lowered.source.type.unionId, narrowed, lowered.source.loc);
+    if (!helper) {
+        lowerer.unsupported("SC1090", call.arguments[0], "a Buffer constructor argument whose narrowed type is not a stored source arm");
+    }
+    return {
+        ...lowered,
+        source: { kind: "call", callee: helper, args: [lowered.source], type: narrowed, loc: lowered.source.loc },
+    };
 }
 function lowerOptionalNumberDefault(lowerer, value, dflt, loc) {
     const widened = lowerer.runtimeOptionalWidening(value.type, F64);
@@ -4509,14 +4537,14 @@ function lowerOptionalNumberDefault(lowerer, value, dflt, loc) {
     }
     return { kind: "call", callee: helper, args: [value], type: F64, loc };
 }
-function lowerStringMethodCallWithOptionalArgs(lowerer, call, access) {
-    const lowered = lowerer.lowerStringMethodCall(call, access);
+function lowerStringMethodCallWithOptionalArgs(lowerer, call, access, receiver, argumentNodes = call.arguments) {
+    const lowered = lowerStringMethodCall(lowerer, call, access, receiver, argumentNodes);
     if (lowered?.kind !== "strIntrinsic")
         return lowered;
     const args = [...lowered.args];
     let changed = false;
     const zeroDefaultArgs = lowered.method === "charCodeAt" || lowered.method === "charAt" ||
-        lowered.method === "repeat" || lowered.method === "padStart" || lowered.method === "padEnd"
+        lowered.method === "repeat"
         ? [0]
         : lowered.method === "slice" || lowered.method === "substring"
             ? [0]
@@ -4537,11 +4565,419 @@ function lowerStringMethodCallWithOptionalArgs(lowerer, call, access) {
         lowered.method === "startsWith" || lowered.method === "endsWith") &&
         args[0]?.type.kind === "union" &&
         lowerer.runtimeOptionalWidening(args[0].type, STRING) !== null) {
-        args[0] = lowerer.ensureString(args[0], call.arguments[0]);
+        args[0] = lowerer.ensureString(args[0], argumentNodes[0]);
         changed = true;
     }
     return changed ? { ...lowered, args } : lowered;
 }
+function lowerNumberConstructorValue(lowerer, argNode, loc) {
+    const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, argNode);
+    if (undefinedArg) {
+        return defaultAfterUndefined(undefinedArg, {
+            kind: "bin", op: "/", left: { kind: "numLit", value: 0, type: F64, loc },
+            right: { kind: "numLit", value: 0, type: F64, loc }, type: F64, loc,
+        });
+    }
+    const arg = lowerer.lowerExpr(argNode);
+    if (arg.type.kind === "nullT")
+        return defaultAfterUndefined(arg, { kind: "numLit", value: 0, type: F64, loc });
+    if (arg.type.kind === "bigint")
+        return { kind: "libCall", fn: "bigint.toF64", args: [arg], type: F64, loc };
+    if (arg.type.kind === "f64")
+        return arg;
+    if (arg.type.kind === "bool") {
+        return {
+            kind: "ternary",
+            cond: arg,
+            then: { kind: "numLit", value: 1, type: F64, loc },
+            else_: { kind: "numLit", value: 0, type: F64, loc },
+            type: F64,
+            loc,
+        };
+    }
+    if (arg.type.kind === "string")
+        return { kind: "libCall", fn: "num.fromString", args: [arg], type: F64, loc };
+    const optionalNumber = lowerOptionalStringNumber(lowerer, arg, loc);
+    if (optionalNumber)
+        return optionalNumber;
+    const scalarUnionNumber = lowerScalarUnionNumber(lowerer, arg, argNode, loc);
+    if (scalarUnionNumber)
+        return scalarUnionNumber;
+    return lowerer.noLowering(`Number of ${lowerer.fmt(arg.type)} values`, argNode, arg.type.kind === "union"
+        ? "unions of numbers, booleans, strings, null, and undefined lower — narrow other arms first"
+        : undefined);
+}
+function immediatePrimitiveWrapperToString(lowerer, node) {
+    const stringValue = stringWrapperToString(lowerer, node);
+    if (stringValue)
+        return stringValue;
+    let wrapped = node;
+    while (ts.isParenthesizedExpression(wrapped))
+        wrapped = wrapped.expression;
+    if (!ts.isNewExpression(wrapped) || !ts.isIdentifier(wrapped.expression))
+        return null;
+    const name = wrapped.expression.text;
+    if ((name !== "Boolean" && name !== "Number") ||
+        !lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(wrapped.expression) ?? undefined))
+        return null;
+    const args = wrapped.arguments ?? [];
+    if (args.length > 1 || args.some(ts.isSpreadElement))
+        return null;
+    const loc = locOf(wrapped);
+    const primitive = name === "Boolean"
+        ? args.length ? lowerer.lowerCondition(args[0]) : { kind: "boolLit", value: false, type: BOOL, loc }
+        : args.length ? lowerNumberConstructorValue(lowerer, args[0], loc) : { kind: "numLit", value: 0, type: F64, loc };
+    return lowerer.ensureString(primitive, wrapped);
+}
+function plainObjectCoercionReceiver(lowerer, node) {
+    const plainLiteral = (literal) => literal.properties.every((prop) => ts.isPropertyAssignment(prop) &&
+        (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) || ts.isNumericLiteral(prop.name)) &&
+        prop.name.text !== "__proto__");
+    let value = node;
+    while (ts.isParenthesizedExpression(value))
+        value = value.expression;
+    if (ts.isObjectLiteralExpression(value))
+        return plainLiteral(value);
+    if (!ts.isIdentifier(value))
+        return false;
+    const symbol = lowerer.resolveValueSymbol(value);
+    const decl = symbol ? lowerer.checker.valueDeclarationOf(symbol) : undefined;
+    if (!symbol || !decl || !ts.isVariableDeclaration(decl) || !decl.initializer ||
+        !ts.isObjectLiteralExpression(decl.initializer) || !plainLiteral(decl.initializer))
+        return false;
+    return bindingNeverReassigned(lowerer, symbol, decl);
+}
+function objectToStringTag(lowerer, type) {
+    switch (type.kind) {
+        case "undefinedT":
+        case "void": return "Undefined";
+        case "nullT": return "Null";
+        case "bool": return "Boolean";
+        case "f64": return "Number";
+        case "string": return "String";
+        case "bigint": return "BigInt";
+        case "symbol": return "Symbol";
+        case "array": return "Array";
+        case "record": return "Object";
+        case "func":
+        case "classval": return "Function";
+        case "date": return "Date";
+        case "regex": return "RegExp";
+        case "map": return "Map";
+        case "set": return "Set";
+        case "promise": return "Promise";
+        case "bytes":
+            return ({ u8: "Uint8Array", u32: "Uint32Array", i32: "Int32Array", f32: "Float32Array", f64: "Float64Array" })[type.elem];
+        case "object":
+            return type.className === "%Error" || lowerer.isSubclassOf(type.className, "%Error") ? "Error" : null;
+        default: return null;
+    }
+}
+function immediateObjectTagReceiver(lowerer, node) {
+    let value = node;
+    while (ts.isParenthesizedExpression(value))
+        value = value.expression;
+    const loc = locOf(value);
+    if (ts.isArrayLiteralExpression(value))
+        return { tag: "Array", effect: lowerer.lowerExpr(value) };
+    if ((ts.isCallExpression(value) || ts.isNewExpression(value)) && ts.isIdentifier(value.expression) &&
+        (value.expression.text === "Array" || value.expression.text === "Error") &&
+        (value.arguments?.length ?? 0) === 0 && lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(value.expression) ?? undefined)) {
+        return { tag: value.expression.text, effect: { kind: "numLit", value: 0, type: F64, loc } };
+    }
+    if (ts.isNewExpression(value) && ts.isIdentifier(value.expression) &&
+        lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(value.expression) ?? undefined)) {
+        const name = value.expression.text;
+        const args = value.arguments ?? [];
+        if (args.length <= 1 && !args.some(ts.isSpreadElement)) {
+            if (name === "String") {
+                const effect = stringWrapperToString(lowerer, value);
+                if (effect)
+                    return { tag: "String", effect };
+            }
+            if (name === "Number")
+                return {
+                    tag: "Number",
+                    effect: args.length ? lowerNumberConstructorValue(lowerer, args[0], loc) : { kind: "numLit", value: 0, type: F64, loc },
+                };
+            if (name === "Boolean")
+                return {
+                    tag: "Boolean",
+                    effect: args.length ? lowerer.lowerCondition(args[0]) : { kind: "boolLit", value: false, type: BOOL, loc },
+                };
+        }
+    }
+    if ((ts.isCallExpression(value) || ts.isNewExpression(value)) &&
+        ts.isIdentifier(value.expression) && value.expression.text === "Object" &&
+        lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(value.expression) ?? undefined)) {
+        const args = value.arguments ?? [];
+        if (args.some(ts.isSpreadElement))
+            return null;
+        const first = args[0];
+        const inner = first && (immediateObjectTagReceiver(lowerer, first) ?? (() => {
+            const effect = lowerer.lowerExpr(first);
+            const tag = isUnitType(effect.type) || effect.type.kind === "void" ? "Object" : objectToStringTag(lowerer, effect.type);
+            return tag === null ? null : { tag, effect };
+        })());
+        if (first && !inner)
+            return null;
+        const stmts = [];
+        if (inner && !isSafeToDiscard(inner.effect))
+            stmts.push({ kind: "exprStmt", expr: inner.effect, loc: inner.effect.loc });
+        for (const extra of args.slice(1)) {
+            const effect = lowerer.lowerExpr(extra);
+            if (!isSafeToDiscard(effect))
+                stmts.push({ kind: "exprStmt", expr: effect, loc: locOf(extra) });
+        }
+        return {
+            tag: inner?.tag ?? "Object",
+            effect: { kind: "seqExpr", stmts, result: { kind: "numLit", value: 0, type: F64, loc }, type: F64, loc },
+        };
+    }
+    return null;
+}
+function lowerObjectOwnPrototypeCall(lowerer, call, access) {
+    if (lowerer.dynamic || access.name.text !== "call" || !ts.isPropertyAccessExpression(access.expression))
+        return null;
+    const method = access.expression;
+    const enumerable = method.name.text === "propertyIsEnumerable";
+    if (method.name.text !== "hasOwnProperty" && !enumerable)
+        return null;
+    const prototype = method.expression;
+    if (!ts.isPropertyAccessExpression(prototype) || prototype.name.text !== "prototype" ||
+        !lowerer.isStdlibGlobal(prototype.expression, "Object") || !lowerer.isStdlibMember(method) ||
+        call.arguments.some(ts.isSpreadElement))
+        return null;
+    return lowerObjectOwnCall(lowerer, call, call.arguments[0], call.arguments[1], call.arguments.slice(2), method.name.text);
+}
+function lowerObjectOwnMethodCall(lowerer, call, access) {
+    const method = access.name.text;
+    if (lowerer.dynamic || call.questionDotToken || access.questionDotToken ||
+        (method !== "hasOwnProperty" && method !== "propertyIsEnumerable") ||
+        !lowerer.isStdlibMember(access) || call.arguments.some(ts.isSpreadElement))
+        return null;
+    return lowerObjectOwnCall(lowerer, call, access.expression, call.arguments[0], call.arguments.slice(1), method);
+}
+function lowerObjectOwnCall(lowerer, call, receiverNode, keyNode, extraNodes, method) {
+    const enumerable = method === "propertyIsEnumerable";
+    const loc = locOf(call);
+    const stmts = [];
+    const receiver = receiverNode ? lowerer.lowerExpr(receiverNode) : { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc };
+    let receiverRef = receiver;
+    if (isUnitType(receiver.type) || receiver.type.kind === "void") {
+        if (!isSafeToDiscard(receiver))
+            stmts.push({ kind: "exprStmt", expr: receiver, loc });
+    }
+    else {
+        const local = lowerer.declareHiddenLocal("%ownReceiver", receiver.type);
+        stmts.push({ kind: "varDecl", localId: local.id, init: receiver, loc });
+        receiverRef = varRef(local.id, receiver.type, loc);
+    }
+    const rawKey = keyNode ? lowerer.lowerExpr(keyNode) : null;
+    let keyRef = rawKey;
+    if (rawKey && (isUnitType(rawKey.type) || rawKey.type.kind === "void")) {
+        if (!isSafeToDiscard(rawKey))
+            stmts.push({ kind: "exprStmt", expr: rawKey, loc: rawKey.loc });
+    }
+    else if (rawKey) {
+        const local = lowerer.declareHiddenLocal("%ownKey", rawKey.type);
+        stmts.push({ kind: "varDecl", localId: local.id, init: rawKey, loc: rawKey.loc });
+        keyRef = varRef(local.id, rawKey.type, loc);
+    }
+    for (const extra of extraNodes) {
+        const effect = lowerer.lowerExpr(extra);
+        if (!isSafeToDiscard(effect))
+            stmts.push({ kind: "exprStmt", expr: effect, loc: locOf(extra) });
+    }
+    let key = keyRef;
+    if (!keyNode || rawKey?.type.kind === "undefinedT" || rawKey?.type.kind === "void") {
+        key = { kind: "strLit", value: "undefined", type: STRING, loc };
+    }
+    else if (rawKey?.type.kind === "nullT") {
+        key = { kind: "strLit", value: "null", type: STRING, loc };
+    }
+    else if (key && (key.type.kind === "f64" || key.type.kind === "bool" || key.type.kind === "bigint")) {
+        key = { kind: "toString", operand: key, type: STRING, loc };
+    }
+    if (!key || key.type.kind !== "string") {
+        lowerer.noLowering("Object.prototype." + method + " with this property key", keyNode ?? call);
+    }
+    let result;
+    const type = receiver.type;
+    if (isUnitType(type) || type.kind === "void") {
+        result = nodeThrowExpr(1, "", "Cannot convert undefined or null to object", BOOL, loc);
+    }
+    else if (type.kind === "record") {
+        const shape = lowerer.shapes.get(type.shapeId);
+        if (!shape || shape.tuple || shape.indexValue || shapeHasAccessorSlots(shape)) {
+            lowerer.noLowering("Object.prototype." + method + " over this record shape", receiverNode ?? call);
+        }
+        result = { kind: "call", callee: recordHasOwnHelper(lowerer, type.shapeId, loc), args: [receiverRef, key], type: BOOL, loc };
+    }
+    else if (type.kind === "dyn" && !enumerable) {
+        result = { kind: "libCall", fn: "dyn.hasOwn", args: [receiverRef, key], type: BOOL, loc };
+    }
+    else if (type.kind === "string" || type.kind === "array") {
+        const needleLocal = lowerer.declareHiddenLocal("%ownIndex", F64);
+        stmts.push({ kind: "varDecl", localId: needleLocal.id, init: { kind: "libCall", fn: "num.fromString", args: [key], type: F64, loc }, loc });
+        const needle = varRef(needleLocal.id, F64, loc);
+        const length = type.kind === "string"
+            ? { kind: "strIntrinsic", method: "length", receiver: receiverRef, args: [], type: F64, loc }
+            : { kind: "arrIntrinsic", method: "length", receiver: receiverRef, args: [], type: F64, loc };
+        const inRange = { kind: "bin", op: "<", left: needle, right: length, type: BOOL, loc };
+        const nonNegative = { kind: "bin", op: ">=", left: needle, right: { kind: "numLit", value: 0, type: F64, loc }, type: BOOL, loc };
+        const integer = { kind: "bin", op: "===", left: needle,
+            right: { kind: "libCall", fn: "math.floor", args: [needle], type: F64, loc }, type: BOOL, loc };
+        const canonical = { kind: "strEq", negated: false, left: key, right: { kind: "toString", operand: needle, type: STRING, loc }, type: BOOL, loc };
+        const present = type.kind === "string" ? { kind: "boolLit", value: true, type: BOOL, loc } :
+            { kind: "bin", op: "===", left: { kind: "arrIntrinsic", method: "nextPresent", receiver: receiverRef, args: [needle], type: F64, loc }, right: needle, type: BOOL, loc };
+        const no = { kind: "boolLit", value: false, type: BOOL, loc };
+        const indexOwn = [inRange, integer, canonical, present].reduce((left, right) => ({ kind: "logical", op: "&&", left, right, type: BOOL, loc }), nonNegative);
+        const lengthOwn = !enumerable
+            ? { kind: "strEq", negated: false, left: key, right: { kind: "strLit", value: "length", type: STRING, loc }, type: BOOL, loc }
+            : no;
+        result = { kind: "logical", op: "||", left: lengthOwn, right: indexOwn, type: BOOL, loc };
+    }
+    else if (type.kind === "f64" || type.kind === "bool" || type.kind === "bigint" || type.kind === "symbol") {
+        result = { kind: "boolLit", value: false, type: BOOL, loc };
+    }
+    else {
+        lowerer.noLowering("Object.prototype." + method + " over a " + lowerer.fmt(type) + " receiver", receiverNode ?? call);
+    }
+    return { kind: "seqExpr", stmts, result, type: BOOL, loc };
+}
+function lowerObjectPrototypeCall(lowerer, call, access) {
+    if (lowerer.dynamic || access.name.text !== "call" || !ts.isPropertyAccessExpression(access.expression))
+        return null;
+    const method = access.expression;
+    const prototype = method.expression;
+    if (method.name.text !== "toString" || !ts.isPropertyAccessExpression(prototype) ||
+        prototype.name.text !== "prototype" || !lowerer.isStdlibGlobal(prototype.expression, "Object") ||
+        !lowerer.isStdlibMember(method) || call.arguments.some(ts.isSpreadElement))
+        return null;
+    const loc = locOf(call);
+    if (call.arguments.length === 0)
+        return { kind: "strLit", value: "[object Undefined]", type: STRING, loc };
+    const receiverNode = call.arguments[0];
+    const immediate = immediateObjectTagReceiver(lowerer, receiverNode);
+    const receiver = immediate?.effect ?? lowerer.lowerExpr(receiverNode);
+    const tag = immediate?.tag ?? objectToStringTag(lowerer, receiver.type);
+    if (tag === null && receiver.type.kind !== "dyn") {
+        lowerer.noLowering("Object.prototype.toString.call over a " + lowerer.fmt(receiver.type) + " receiver", receiverNode);
+    }
+    const stmts = [];
+    let ref = receiver;
+    if (isUnitType(receiver.type) || receiver.type.kind === "void") {
+        if (!isSafeToDiscard(receiver))
+            stmts.push({ kind: "exprStmt", expr: receiver, loc });
+    }
+    else {
+        const local = lowerer.declareHiddenLocal("%objectTagReceiver", receiver.type);
+        stmts.push({ kind: "varDecl", localId: local.id, init: receiver, loc });
+        ref = varRef(local.id, receiver.type, loc);
+    }
+    for (const extra of call.arguments.slice(1)) {
+        stmts.push({ kind: "exprStmt", expr: lowerer.lowerExpr(extra), loc: locOf(extra) });
+    }
+    const result = tag === null
+        ? { kind: "libCall", fn: "dyn.objectTag", args: [ref], type: STRING, loc }
+        : { kind: "strLit", value: "[object " + tag + "]", type: STRING, loc };
+    return { kind: "seqExpr", stmts, result, type: STRING, loc };
+}
+function lowerStringPrototypeCall(lowerer, call, access) {
+    if (access.name.text !== "call" || !ts.isPropertyAccessExpression(access.expression))
+        return null;
+    const methodAccess = access.expression;
+    const prototypeAccess = methodAccess.expression;
+    if (!ts.isPropertyAccessExpression(prototypeAccess) || prototypeAccess.name.text !== "prototype" ||
+        !ts.isIdentifier(prototypeAccess.expression) || prototypeAccess.expression.text !== "String" ||
+        (!Object.hasOwn(STR_METHODS, methodAccess.name.text) && !STRING_INDEX_METHODS.has(methodAccess.name.text)) ||
+        !lowerer.isStdlibMember(methodAccess))
+        return null;
+    if (call.arguments.some(ts.isSpreadElement))
+        return null;
+    const entry = STR_METHODS[methodAccess.name.text];
+    const indexMethod = STRING_INDEX_METHODS.has(methodAccess.name.text) ? methodAccess.name.text : null;
+    const resultType = indexMethod ? lowerer.withUndefinedArmOf(indexMethod === "at" ? STRING : F64) : entry?.result;
+    if (!resultType)
+        return null;
+    const method = methodAccess.name.text === "trimStart" ? "trimLeft" :
+        methodAccess.name.text === "trimEnd" ? "trimRight" : methodAccess.name.text;
+    const loc = locOf(call);
+    const nullishError = nodeThrowExpr(1, "", `String.prototype.${method} called on null or undefined`, resultType, loc);
+    const receiverNode = call.arguments[0];
+    if (!receiverNode)
+        return nullishError;
+    // Receiver coercion runs after .call has evaluated its arguments; keep
+    // contextual wrapper lowering on forms without later method arguments.
+    const immediateWrapper = entry?.maxArgs === 0 && call.arguments.length === 1
+        ? immediatePrimitiveWrapperToString(lowerer, receiverNode) : null;
+    const receiverValue = immediateWrapper ?? lowerer.lowerExpr(receiverNode);
+    const receiverType = receiverValue.type;
+    const nullish = isUnitType(receiverType) || receiverType.kind === "void" ||
+        (receiverType.kind === "union" && (lowerer.unions.get(receiverType.unionId)?.arms.every((arm) => isUnitType(arm) || arm.kind === "void") ?? false));
+    if (nullish) {
+        const values = [receiverValue, ...call.arguments.slice(1).map((arg) => lowerer.lowerExpr(arg))];
+        return {
+            kind: "seqExpr",
+            stmts: values.filter((value) => !isSafeToDiscard(value)).map((value) => ({ kind: "exprStmt", expr: value, loc: value.loc })),
+            result: nullishError,
+            type: resultType,
+            loc,
+        };
+    }
+    const padding = entry?.method === "padStart" || entry?.method === "padEnd";
+    const scalar = receiverType.kind === "string" || receiverType.kind === "f64" ||
+        receiverType.kind === "bool" || receiverType.kind === "bigint" ||
+        (receiverType.kind === "union" && (lowerer.unions.get(receiverType.unionId)?.arms.every((arm) => arm.kind === "string" || arm.kind === "f64" || arm.kind === "bool" || arm.kind === "bigint") ?? false));
+    // Other methods convert object receivers before lowering their arguments;
+    // padding uses a helper that delays conversion until every argument is ready.
+    const objectWithoutMethodArgs = entry?.maxArgs === 0 && call.arguments.length === 1 &&
+        (receiverType.kind === "record" || receiverType.kind === "array" || receiverType.kind === "object");
+    const dynObjectWithoutMethodArgs = entry?.maxArgs === 0 && call.arguments.length === 1 &&
+        receiverType.kind === "dyn" && plainObjectCoercionReceiver(lowerer, receiverNode);
+    if (!scalar && !objectWithoutMethodArgs && !dynObjectWithoutMethodArgs && !(padding && receiverType.kind === "dyn")) {
+        return lowerer.noLowering(`String.prototype.${methodAccess.name.text}.call with ${lowerer.fmt(receiverType)} receivers`, call);
+    }
+    if (indexMethod)
+        return lowerStringIndexCall(lowerer, call, indexMethod, receiverValue, receiverNode, call.arguments.slice(1));
+    if (!entry)
+        return null;
+    if (padding) {
+        return lowerStringPaddingCall(lowerer, call, entry.method, receiverValue, receiverNode, call.arguments.slice(1));
+    }
+    if (entry.method === "split") {
+        return lowerStringSplitCall(lowerer, call, receiverValue, receiverNode, call.arguments.slice(1));
+    }
+    const receiver = dynObjectWithoutMethodArgs
+        ? { kind: "libCall", fn: "dyn.toStringCoerce", args: [receiverValue], type: STRING, loc }
+        : lowerer.ensureString(receiverValue, receiverNode);
+    return lowerStringMethodCallWithOptionalArgs(lowerer, call, methodAccess, () => receiver, call.arguments.slice(1));
+}
+function lowerScalarUnionNumber(lowerer, arg, node, loc) {
+    if (arg.type.kind !== "union" || !lowerer.unions.get(arg.type.unionId)?.arms.every((arm) => arm.kind === "f64" || arm.kind === "string" || arm.kind === "bool" || isUnitType(arm)))
+        return null;
+    const key = `number.scalar:${arg.type.unionId}`;
+    let helper = lowerer.widthHelpers.get(key);
+    if (!helper) {
+        helper = `%number.scalar.${lowerer.widthHelpers.size}`;
+        lowerer.widthHelpers.set(key, helper);
+        const value = varRef("value.0", arg.type, loc);
+        const nan = {
+            kind: "bin", op: "/", left: { kind: "numLit", value: 0, type: F64, loc },
+            right: { kind: "numLit", value: 0, type: F64, loc }, type: F64, loc,
+        };
+        lowerer.liftedFns.push({
+            name: helper,
+            params: [{ localId: "value.0", name: "value", type: arg.type }],
+            returnType: F64,
+            locals: [{ id: "value.0", name: "value", type: arg.type, mutable: false }],
+            body: [{ kind: "return", value: positionNumber(lowerer, value, nan, node, "Number argument"), loc }],
+            loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: [arg], type: F64, loc };
+}
 function lowerOptionalStringNumber(lowerer, arg, loc, fn = "num.fromString", label = "number") {
     if (arg.type.kind !== "union")
         return null;
@@ -5893,26 +6329,23 @@ export function lambdaSignature(lowerer, node) {
             ret = VOID;
         }
     }
-    // VARIADIC JS functions: a dynRest param (above), or a plain function
-    // whose body reads `arguments` (test/common's mustCall wrapper —
-    // `function() { ...; return fn.apply(this, arguments); }`). Both mark
-    // the func type `rest`: the lifted body takes one trailing dyn-array
-    // param, filled by the boxed call thunk with the call's arguments
-    // from index params.length on. `arguments` is only claimed in
-    // ZERO-param functions (there it IS the surplus array); alongside
-    // declared params the alias story has no model — the fence says to
-    // use a rest parameter. Arrows never claim it (JS: an arrow's
-    // `arguments` is the enclosing function's).
-    const hasDynRest = shapes.some((s) => s.mode === "dynRest");
-    const usesArguments = !hasDynRest &&
-        !ts.isArrowFunction(node) &&
+    // A plain JS function reading `arguments` receives one hidden dyn
+    // array. With named parameters, the array contains every actual
+    // argument and only ES modules are admitted: sloppy-mode arguments
+    // alias named parameters. Arrows inherit the enclosing `arguments`.
+    const hasRest = shapes.some((s) => s.mode === "rest" || s.mode === "dynRest" || s.mode === "islandRest");
+    const usesArguments = !hasRest &&
+        (ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) &&
         isJsSourceFile(node.getSourceFile()) &&
         bodyReadsArguments(node);
     if (usesArguments && node.parameters.length > 0) {
-        lowerer.unsupported("SC1090", node, "'arguments' in functions with declared parameters (use a rest parameter: (...args))");
+        if (!isNodeEsmFile(node.getSourceFile())) {
+            lowerer.unsupported("SC1090", node, "parameterized 'arguments' outside an ES module (sloppy-mode parameter aliases)");
+        }
+        shapes.push({ type: DYN, mode: "arguments" });
     }
     const funcType = funcTypeFromParamShapes(shapes, ret);
-    if (usesArguments && !hasDynRest)
+    if (usesArguments)
         funcType.rest = true;
     return { shapes, funcType };
 }
@@ -5988,9 +6421,9 @@ export function lowerLambda(lowerer, node) {
     lowerer.fnStack.push(fnCtx);
     try {
         const { params, prologue } = lowerer.declareParams(node.parameters, shapes);
-        // The VARIADIC `arguments` form (rest-marked with no declared rest
-        // param): a synthetic trailing dyn-array param carries the call's
-        // arguments; `arguments` reads resolve to it (identifier lowering).
+        // The synthetic trailing dyn-array param carries `arguments`.
+        // Parameterized functions receive all actual arguments; zero-param
+        // functions receive the same array through their rest ABI.
         if (funcType.rest && !shapes.some((s) => s.mode === "dynRest" || s.mode === "islandRest")) {
             const argsLocal = lowerer.declareHiddenLocal("%arguments", DYN);
             params.push({ localId: argsLocal.id, name: "%arguments", type: DYN });
@@ -7072,9 +7505,10 @@ function lowerBigIntMethodCall(lowerer, call, access) {
     if (name === "valueOf" && call.arguments.length === 0)
         return receiver;
     if (name === "toString" && call.arguments.length <= 1) {
+        const defaultRadix = { kind: "numLit", value: 10, type: F64, loc };
         const radix = call.arguments[0]
-            ? lowerer.lowerExprExpecting(call.arguments[0], F64)
-            : { kind: "numLit", value: 10, type: F64, loc };
+            ? lowerOptionalArgument(lowerer, call.arguments[0], F64, defaultRadix)
+            : defaultRadix;
         return { kind: "libCall", fn: "bigint.toString", args: [receiver, radix], type: STRING, loc };
     }
     return null;
@@ -8092,10 +8526,9 @@ export function lowerFunction(lowerer, decl) {
     lowerer.fnStack.push(ctx);
     try {
         const { params, prologue } = lowerer.declareParams(decl.parameters, sig.params);
-        // The synthetic `arguments` slot (a dynRest shape BEYOND the declared
-        // parameters — collectSignatureInner appended it): one trailing
-        // dyn-array param, resolved by `arguments` reads.
-        if (sig.params.length > decl.parameters.length && sig.params[sig.params.length - 1].mode === "dynRest") {
+        // The synthetic `arguments` slot follows the declared parameters;
+        // reads resolve to this dyn array.
+        if (sig.params.length > decl.parameters.length && (sig.params[sig.params.length - 1].mode === "dynRest" || sig.params[sig.params.length - 1].mode === "arguments")) {
             const argsLocal = lowerer.declareHiddenLocal("%arguments", DYN);
             params.push({ localId: argsLocal.id, name: "%arguments", type: DYN });
             ctx.argumentsLocal = argsLocal;