@scriptc/compiler 0.1.5 → 0.1.7

package/dist/frontend/lowering/lower-calls.d.ts

@@ -1,8 +1,10 @@
 import * as ts from "../ts7/adapter.js";
+import { bodyReadsArguments } from "../arguments-usage.js";
 import type { Lowerer } from "./lowerer.js";
 import { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/ir.js";
 import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { type ClassInfo } from "./lower-classes.js";
+export { bodyReadsArguments };
 /** How a parameter participates in CALL-SITE COMPLETION (the frontend
  * completes every call to the one full signature, so the IR and backends
  * stay count-exact — see docs/ir.md). `required` params must be passed;
@@ -423,15 +425,6 @@ export declare function lambdaSignature(lowerer: Lowerer, node: ts.ArrowFunction
         kind: "func";
     };
 };
-/** Does this function's OWN body read `arguments`? Nested plain functions
-   * and methods have their own `arguments` (the walk skips them); arrows
-   * see the enclosing one (the walk descends). Exported for the lowerer's
-   * dynFallbackType: tsgo does not synthesize the `arguments` rest
-   * parameter into inferred signatures (5.9.3 did — its param-count
-   * mismatch was the detector), so the 7 world asks the BODY directly. */
-export declare function bodyReadsArguments(fn: {
-    body?: ts.Node | undefined;
-}): boolean;
 /** Lifts an arrow function / function expression / nested declaration /
    * object-literal shorthand method to a module-level function and yields
    * the `closure` expression creating it. */

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

@@ -4,18 +4,19 @@ import { InternalCompilerError } from "../../errors.js";
  * function/lambda lowering and signature collection, and monomorphizing
  * generic instantiation (bounded by MAX_GENERIC_INSTANCES). */
 import * as ts from "../ts7/adapter.js";
+import { bodyReadsArguments } from "../arguments-usage.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, 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, STR_METHODS, 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, lowerStringPaddingCall } 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, stringWrapperToString, templateRawTextOf } from "./lower-exprs.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
@@ -33,6 +34,7 @@ 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";
+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
  * mark the value variadic so indirect call sites run completeArgs before
@@ -3581,6 +3583,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.
@@ -4188,6 +4193,8 @@ 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
@@ -4217,6 +4224,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
@@ -4257,6 +4265,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).
@@ -4640,6 +4649,243 @@ function plainObjectCoercionReceiver(lowerer, node) {
         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;
@@ -4647,21 +4893,26 @@ function lowerStringPrototypeCall(lowerer, call, access) {
     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) || !lowerer.isStdlibMember(methodAccess))
+        (!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`, entry.result, loc);
+    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
+    const immediateWrapper = entry?.maxArgs === 0 && call.arguments.length === 1
         ? immediatePrimitiveWrapperToString(lowerer, receiverNode) : null;
     const receiverValue = immediateWrapper ?? lowerer.lowerExpr(receiverNode);
     const receiverType = receiverValue.type;
@@ -4673,26 +4924,33 @@ function lowerStringPrototypeCall(lowerer, call, access) {
             kind: "seqExpr",
             stmts: values.filter((value) => !isSafeToDiscard(value)).map((value) => ({ kind: "exprStmt", expr: value, loc: value.loc })),
             result: nullishError,
-            type: entry.result,
+            type: resultType,
             loc,
         };
     }
-    const padding = entry.method === "padStart" || entry.method === "padEnd";
+    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 &&
+    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 &&
+    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);
@@ -6093,31 +6351,6 @@ export function lambdaSignature(lowerer, node) {
         funcType.rest = true;
     return { shapes, funcType };
 }
-/** Does this function's OWN body read `arguments`? Nested plain functions
-   * and methods have their own `arguments` (the walk skips them); arrows
-   * see the enclosing one (the walk descends). Exported for the lowerer's
-   * dynFallbackType: tsgo does not synthesize the `arguments` rest
-   * parameter into inferred signatures (5.9.3 did — its param-count
-   * mismatch was the detector), so the 7 world asks the BODY directly. */
-export function bodyReadsArguments(fn) {
-    let found = false;
-    if (fn.body === undefined)
-        return false;
-    // Iterative walk (walkPreorder): function bodies can hold pathologically
-    // deep expression chains that a recursive visit would die on.
-    ts.walkPreorder(fn.body, (n) => {
-        if (ts.isIdentifier(n) && n.text === "arguments" && !(ts.isPropertyAccessExpression(n.parent) && n.parent.name === n)) {
-            found = true;
-            return "stop";
-        }
-        if ((ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n) || ts.isMethodDeclaration(n)) &&
-            n !== fn) {
-            return "skip"; // own `arguments` scope
-        }
-        return undefined;
-    });
-    return found;
-}
 /** Lifts an arrow function / function expression / nested declaration /
    * object-literal shorthand method to a module-level function and yields
    * the `closure` expression creating it. */
@@ -6313,9 +6546,8 @@ export function lowerLambda(lowerer, node) {
    * becomes the catch binding, and a handler VALUE would need a
    * caught-typed closure parameter, which cannot exist. finally takes
    * any () => void closure (its callback sees no arguments). then takes
-   * exactly one FULFILLMENT handler (any closure value of the settled
-   * value's type — the two-argument onRejected form stays fenced toward
-   * .catch); a promise-returning handler flattens through the async
+   * a fulfillment handler and optionally a rejection handler; a
+   * promise-returning handler flattens through the async
    * return path, a receiver rejection passes through untouched (the
    * wrapper's await re-throws it), and a handler throw rejects the
    * result — the spec's onFulfilled rules by construction. Null for
@@ -6414,9 +6646,9 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
     };
     const passthrough = call.arguments.length === 0 ||
         (call.arguments.length === 1 && isAbsentHandler(call.arguments[0]));
-    if (call.arguments.length !== 1 && !passthrough) {
+    if (call.arguments.length !== 1 && !passthrough && !(member === "then" && call.arguments.length === 2)) {
         lowerer.noLowering(`${member} with ${call.arguments.length} arguments`, call, member === "then"
-            ? "the supported form takes exactly one fulfillment handler — chain .catch(...) for the rejection half"
+            ? "the supported form takes a fulfillment handler and an optional rejection handler"
             : `the supported form takes exactly one ${member === "catch" ? "inline handler" : "callback"}`);
     }
     // The receiver evaluates FIRST, in the enclosing function, like JS.
@@ -6488,6 +6720,140 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         }
     }
     if (member === "then") {
+        if (call.arguments.length === 2) {
+            const fulfilledNode = call.arguments[0];
+            const rejectedNode = call.arguments[1];
+            const fulfilledAbsent = isAbsentHandler(fulfilledNode);
+            const rejectedAbsent = isAbsentHandler(rejectedNode);
+            const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
+            if (resultT?.kind !== "promise") {
+                lowerer.noLowering("then with these handlers", call, "the result must be a representable promise");
+            }
+            const R = resultT.inner;
+            if (!fulfilledAbsent && inner.kind === "jsval")
+                markJsvalHandlerParams(lowerer, fulfilledNode);
+            if (!fulfilledAbsent && inner.kind === "moduleNs")
+                markModuleNsHandlerParams(lowerer, fulfilledNode, inner);
+            const boxHandler = (node, allowDirect) => {
+                const value = lowerer.lowerExpr(node);
+                if (allowDirect && value.type.kind === "func" && value.type.params.length <= 1 &&
+                    (value.type.params.length === 0 || (inner.kind !== "void" && typeEquals(value.type.params[0], inner)))) {
+                    return { value, direct: true, returnsPromise: value.type.ret.kind === "promise" };
+                }
+                if (value.type.kind === "dyn")
+                    return { value, direct: false, returnsPromise: false };
+                if (value.type.kind === "func" && value.type.params.length <= 1 &&
+                    canBoxFuncIntoDyn(value.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+                    return { value: { kind: "dynFrom", value, type: DYN, loc }, direct: false, returnsPromise: value.type.ret.kind === "promise" };
+                }
+                lowerer.unsupported("SC1090", node, "then handlers that cannot be called with one value");
+            };
+            // Evaluate both callback expressions before the wrapper runs, in source order.
+            const fulfilled = fulfilledAbsent ? null : boxHandler(fulfilledNode, true);
+            const rejected = rejectedAbsent ? null : boxHandler(rejectedNode, false);
+            const fnName = `%fn${lowerer.lambdaCounter++}_then2`;
+            const paramTypes = [promT, ...(fulfilled ? [fulfilled.value.type] : []), ...(rejected ? [DYN] : [])];
+            const funcType = { kind: "func", params: paramTypes, ret: resultT };
+            const fnCtx = newFnCtx(true, null, funcType, R);
+            fnCtx.isAsync = true;
+            lowerer.fnStack.push(fnCtx);
+            try {
+                const pLocal = lowerer.declareHiddenLocal("p", promT);
+                const fLocal = fulfilled ? lowerer.declareHiddenLocal("f", fulfilled.value.type) : null;
+                const rLocal = rejected ? lowerer.declareHiddenLocal("r", DYN) : null;
+                const eLocal = lowerer.declareHiddenLocal("e", CAUGHT);
+                const vLocal = inner.kind === "void" ? null : lowerer.declareHiddenLocal("v", inner);
+                const awaitE = {
+                    kind: "awaitExpr",
+                    value: { kind: "varRef", localId: pLocal.id, type: promT, loc },
+                    type: inner,
+                    loc,
+                };
+                const tryBody = vLocal
+                    ? [{ kind: "varDecl", localId: vLocal.id, init: awaitE, loc }]
+                    : [{ kind: "exprStmt", expr: awaitE, loc }];
+                const resultOf = (value, returnsPromise = false) => {
+                    const settled = value.type.kind === "promise"
+                        ? { kind: "awaitExpr", value, type: value.type.inner, loc }
+                        : returnsPromise
+                            ? { kind: "libCall", fn: "async.awaitDyn", args: [value], type: DYN, loc }
+                            : value;
+                    return R.kind === "void"
+                        ? [{ kind: "exprStmt", expr: settled, loc }, { kind: "return", value: null, loc }]
+                        : [{ kind: "return", value: lowerer.coerceInto(call, settled, R), loc }];
+                };
+                const rejectedCall = rLocal ? {
+                    kind: "dynCall",
+                    callee: { kind: "varRef", localId: rLocal.id, type: DYN, loc },
+                    calleeName: jsFuncNameOf(rejectedNode) ?? "onRejected",
+                    args: [{ kind: "caughtToDyn", value: { kind: "varRef", localId: eLocal.id, type: CAUGHT, loc }, type: DYN, loc }],
+                    type: DYN,
+                    loc,
+                } : null;
+                const catchBody = rejectedCall
+                    ? resultOf(rejectedCall, rejected?.returnsPromise)
+                    : [{ kind: "rethrow", localId: eLocal.id, loc }];
+                const body = [{ kind: "tryCatch", tryBody, catchBody, catchLocalId: eLocal.id, finallyBody: null, loc }];
+                // The fulfillment callback sits after the catch so a throw from it
+                // rejects the result instead of reaching onRejected.
+                if (fLocal) {
+                    const settled = vLocal
+                        ? { kind: "varRef", localId: vLocal.id, type: inner, loc }
+                        : dynUndefinedExpr(loc);
+                    if (fulfilled.direct && fLocal.type.kind === "func") {
+                        body.push(...resultOf({
+                            kind: "callValue",
+                            callee: { kind: "varRef", localId: fLocal.id, type: fLocal.type, loc },
+                            args: fLocal.type.params.length === 0 ? [] : [settled],
+                            type: fLocal.type.ret,
+                            loc,
+                        }));
+                    }
+                    else {
+                        const arg = settled.type.kind === "dyn" ? settled
+                            : canConvertToDyn(settled.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))
+                                ? { kind: "dynFrom", value: settled, type: DYN, loc }
+                                : lowerer.unsupported("SC1090", fulfilledNode, "then fulfillment values that cannot cross the checked-dynamic boundary");
+                        body.push(...resultOf({
+                            kind: "dynCall",
+                            callee: { kind: "varRef", localId: fLocal.id, type: DYN, loc },
+                            calleeName: jsFuncNameOf(fulfilledNode) ?? "onFulfilled",
+                            args: [arg], type: DYN, loc,
+                        }, fulfilled?.returnsPromise));
+                    }
+                }
+                else if (vLocal) {
+                    body.push(...resultOf({ kind: "varRef", localId: vLocal.id, type: inner, loc }));
+                }
+                else if (R.kind === "void") {
+                    body.push({ kind: "return", value: null, loc });
+                }
+                else {
+                    body.push({ kind: "return", value: lowerer.coerceInto(call, dynUndefinedExpr(loc), R), loc });
+                }
+                const ctx = lowerer.ctx;
+                const lifted = {
+                    name: fnName,
+                    params: [
+                        { localId: pLocal.id, name: pLocal.name, type: promT },
+                        ...(fLocal ? [{ localId: fLocal.id, name: fLocal.name, type: fLocal.type }] : []),
+                        ...(rLocal ? [{ localId: rLocal.id, name: rLocal.name, type: DYN }] : []),
+                    ],
+                    returnType: R,
+                    locals: ctx.locals,
+                    captures: ctx.captures,
+                    body,
+                    loc,
+                    async: true,
+                };
+                lowerer.liftedFns.push(lifted);
+                const closure = { kind: "closure", fnName, captures: ctx.captureSources, type: funcType, loc };
+                return { kind: "callValue", callee: closure, args: [receiver, ...(fulfilled ? [fulfilled.value] : []), ...(rejected ? [rejected.value] : [])], type: resultT, loc };
+            }
+            finally {
+                lowerer.fnStack.pop();
+            }
+        }
         // The settled value is an island HANDLE: an inline handler's
         // unannotated parameter binds it as jsval, whatever the checker's
         // contextual type spelled (a module-namespace type has no mapping —