@scriptc/compiler 0.1.4 → 0.1.6

package/dist/frontend/lowering/containers/string-and-regexp.js

@@ -1,15 +1,119 @@
 import * as ts from "../../ts7/adapter.js";
-import { BOOL, F64, STRING, arrayOf, isUnitType, typeEquals } from "../../../ir/ir.js";
-import { numLit, varRef } from "../../../ir/build.js";
+import { BOOL, DYN, F64, STRING, UNDEFINED_T, arrayOf, isUnitType, typeEquals, typeKey } from "../../../ir/ir.js";
+import { numLit, strLit, varRef } from "../../../ir/build.js";
 import { locOf } from "../../program.js";
-import { own } from "../lowerer.js";
+import { nodeThrowExpr, own } from "../lowerer.js";
 import { isRequireMainFilename } from "../expressions/optional-chains.js";
-import { STR_METHODS } from "../surfaces.js";
-import { lowerOptionalArgument } from "../optional-arguments.js";
+import { STRING_INDEX_METHODS, STR_METHODS } from "../surfaces.js";
+import { coerceStringSearchValue, defaultAfterUndefined, lowerOptionalArgument, lowerPositionArgument, lowerStaticallyUndefinedArgument, lowerStringSearchArgument, positionNumber } from "../optional-arguments.js";
 function lowerSplitLimitArg(lowerer, node, loc) {
     const defaultValue = { kind: "numLit", value: 4294967295, type: F64, loc };
     return node ? lowerOptionalArgument(lowerer, node, F64, defaultValue) : defaultValue;
 }
+/** Split evaluates its arguments before converting the receiver, limit, and
+ * separator, in that order. An undefined separator returns the whole string
+ * unless ToUint32(limit) is zero; the string-separator intrinsic handles the
+ * remaining split loop. */
+export function lowerStringSplitCall(lowerer, call, receiver, receiverNode, argumentNodes) {
+    const loc = locOf(call);
+    if (argumentNodes.length > 2 || argumentNodes.some(ts.isSpreadElement)) {
+        return lowerer.noLowering(`.split with ${argumentNodes.length} arguments`, call);
+    }
+    const separatorNode = argumentNodes[0];
+    const undefinedSeparator = separatorNode ? lowerStaticallyUndefinedArgument(lowerer, separatorNode) : null;
+    const absent = !separatorNode || undefinedSeparator !== null;
+    let separator = absent
+        ? undefinedSeparator
+            ? defaultAfterUndefined(undefinedSeparator, strLit("undefined", loc))
+            : strLit("undefined", loc)
+        : lowerer.lowerExpr(separatorNode);
+    if (separator.type.kind === "nullT")
+        separator = defaultAfterUndefined(separator, strLit("null", loc));
+    const scalar = separator.type.kind === "string" || separator.type.kind === "f64" ||
+        separator.type.kind === "bool" || separator.type.kind === "bigint" ||
+        (separator.type.kind === "union" && (lowerer.unions.get(separator.type.unionId)?.arms.every((arm) => arm.kind === "string" || arm.kind === "f64" || arm.kind === "bool" ||
+            arm.kind === "bigint" || arm.kind === "nullT" || arm.kind === "undefinedT") ?? false));
+    if (!scalar) {
+        lowerer.unsupported("SC1090", separatorNode ?? call, `'.split()' on a '${lowerer.fmt(separator.type)}' separator (pass a string, or a regex literal)`);
+    }
+    const defaultLimit = numLit(4294967295, loc);
+    const suppliedLimit = lowerPositionArgument(lowerer, argumentNodes[1], defaultLimit);
+    const limit = suppliedLimit.type.kind === "record" && argumentNodes[1]
+        ? lowerer.coerceInto(argumentNodes[1], suppliedLimit, DYN) : suppliedLimit;
+    const resultType = arrayOf(STRING);
+    if (receiver.type.kind === "string" && separator.type.kind === "string" && limit.type.kind === "f64" && !absent) {
+        return { kind: "strIntrinsic", method: "split", receiver, args: [separator, limit], type: resultType, loc };
+    }
+    const key = `str.split:${receiver.type.kind === "union" ? typeKey(receiver.type) : receiver.type.kind}:${typeKey(separator.type)}:${typeKey(limit.type)}:${absent}`;
+    let helper = lowerer.widthHelpers.get(key);
+    if (!helper) {
+        helper = `%str.split.${lowerer.widthHelpers.size}`;
+        const values = [receiver, separator, limit];
+        const params = values.map((value, index) => ({ localId: `arg.${index}`, name: `arg${index}`, type: value.type }));
+        const rawReceiver = varRef("arg.0", receiver.type, loc);
+        const rawSeparator = varRef("arg.1", separator.type, loc);
+        const rawLimit = varRef("arg.2", limit.type, loc);
+        const stringReceiver = varRef("receiver.0", STRING, loc);
+        const numericLimit = varRef("limit.0", F64, loc);
+        const stringSeparator = varRef("separator.0", STRING, loc);
+        const undefinedTag = separator.type.kind === "union"
+            ? lowerer.unions.get(separator.type.unionId).arms.findIndex((arm) => arm.kind === "undefinedT") : -1;
+        const separatorIsUndefined = absent
+            ? { kind: "boolLit", value: true, type: BOOL, loc }
+            : undefinedTag >= 0 && separator.type.kind === "union"
+                ? { kind: "unionIsTag", unionId: separator.type.unionId, tag: undefinedTag, value: rawSeparator, negated: false, type: BOOL, loc }
+                : { kind: "boolLit", value: false, type: BOOL, loc };
+        const split = {
+            kind: "strIntrinsic", method: "split", receiver: stringReceiver,
+            args: [stringSeparator, numericLimit], type: resultType, loc,
+        };
+        const result = {
+            kind: "ternary",
+            cond: {
+                kind: "bin", op: "===",
+                left: { kind: "bin", op: ">>>", left: numericLimit, right: numLit(0, loc), type: F64, loc },
+                right: numLit(0, loc), type: BOOL, loc,
+            },
+            then: { kind: "arrayLit", elems: [], type: resultType, loc },
+            else_: {
+                kind: "ternary", cond: separatorIsUndefined,
+                then: { kind: "arrayLit", elems: [stringReceiver], type: resultType, loc },
+                else_: split, type: resultType, loc,
+            },
+            type: resultType, loc,
+        };
+        lowerer.widthHelpers.set(key, helper);
+        lowerer.liftedFns.push({
+            name: helper, params, returnType: resultType,
+            locals: [
+                ...params.map(param => ({ id: param.localId, name: param.name, type: param.type, mutable: false })),
+                { id: "receiver.0", name: "receiver", type: STRING, mutable: false },
+                { id: "limit.0", name: "limit", type: F64, mutable: false },
+                { id: "separator.0", name: "separator", type: STRING, mutable: false },
+            ],
+            body: [
+                { kind: "varDecl", localId: "receiver.0", init: lowerer.ensureString(rawReceiver, receiverNode), loc },
+                { kind: "varDecl", localId: "limit.0", init: positionNumber(lowerer, rawLimit, defaultLimit, argumentNodes[1] ?? call, "string split limit"), loc },
+                { kind: "varDecl", localId: "separator.0", init: lowerer.ensureString(rawSeparator, separatorNode ?? call), loc },
+                { kind: "return", value: result, loc },
+            ],
+            loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: [receiver, separator, limit], type: resultType, loc };
+}
+function lowerRegexSubject(lowerer, node, loc) {
+    const absent = { kind: "strLit", value: "undefined", type: STRING, loc };
+    if (!node)
+        return absent;
+    const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, node);
+    if (undefinedArg)
+        return defaultAfterUndefined(undefinedArg, absent);
+    const value = lowerer.lowerExpr(node);
+    if (value.kind === "unitLit")
+        return { kind: "strLit", value: value.unit, type: STRING, loc };
+    return lowerer.ensureString(value, node);
+}
 /** Extract the checker-proven receiver arm from a runtime-optional property
  * read. The receiver is stabilized once before its tag is tested, and a
  * missing value throws the same property-read TypeError Node throws before
@@ -23,6 +127,192 @@ function lowerMethodReceiver(lowerer, node, expected, member) {
         return lowered;
     return lowerer.coerceInto(node, lowered, expected);
 }
+/** Relative string indexing and code-point decoding over the UTF-16 intrinsics. */
+export function lowerStringIndexCall(lowerer, call, method, receiver, receiverNode, argumentNodes) {
+    const loc = locOf(call);
+    if (argumentNodes.length > 1 || argumentNodes.some(ts.isSpreadElement)) {
+        return lowerer.noLowering(`String.prototype.${method} with ${argumentNodes.length} arguments`, call);
+    }
+    const indexNode = argumentNodes[0];
+    let index = lowerPositionArgument(lowerer, indexNode, numLit(0, loc));
+    if (indexNode && (index.type.kind === "record" || index.type.kind === "array" || index.type.kind === "func")) {
+        index = lowerer.coerceInto(indexNode, index, DYN);
+    }
+    const valueType = method === "at" ? STRING : F64;
+    const resultType = lowerer.withUndefinedArmOf(valueType);
+    if (!resultType || resultType.kind !== "union")
+        return lowerer.noLowering(`String.prototype.${method} result`, call);
+    const undefinedTag = lowerer.armTag(resultType.unionId, UNDEFINED_T);
+    const valueTag = lowerer.armTag(resultType.unionId, valueType);
+    const key = `str.index:${method}:${typeKey(receiver.type)}:${typeKey(index.type)}`;
+    let helper = lowerer.widthHelpers.get(key);
+    if (!helper) {
+        helper = `%str.index.${lowerer.widthHelpers.size}`;
+        lowerer.widthHelpers.set(key, helper);
+        const rawReceiver = varRef("arg.0", receiver.type, loc);
+        const rawIndex = varRef("arg.1", index.type, loc);
+        const stringReceiver = varRef("receiver.0", STRING, loc);
+        const length = varRef("length.0", F64, loc);
+        const position = varRef("position.0", F64, loc);
+        const first = varRef("first.0", F64, loc);
+        const second = varRef("second.0", F64, loc);
+        const bin = (op, left, right) => ({ kind: "bin", op, left, right, type: op === "<" || op === ">=" || op === ">" ? BOOL : F64, loc });
+        const either = (left, right) => ({ kind: "logical", op: "||", left, right, type: BOOL, loc });
+        const wrap = (value) => ({ kind: "unionWrap", unionId: resultType.unionId, tag: valueTag, value, type: resultType, loc });
+        const miss = {
+            kind: "unionWrap", unionId: resultType.unionId, tag: undefinedTag,
+            value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, type: resultType, loc,
+        };
+        const numeric = positionNumber(lowerer, rawIndex, numLit(0, loc), indexNode ?? call, "string index");
+        const numericValue = varRef("numeric.0", F64, loc);
+        const body = [
+            { kind: "varDecl", localId: "receiver.0", init: lowerer.ensureString(rawReceiver, receiverNode), loc },
+            { kind: "varDecl", localId: "length.0", init: { kind: "strIntrinsic", method: "length", receiver: stringReceiver, args: [], type: F64, loc }, loc },
+            { kind: "varDecl", localId: "numeric.0", init: numeric, loc },
+            { kind: "varDecl", localId: "position.0", init: {
+                    kind: "ternary", cond: { kind: "libCall", fn: "num.isNaN", args: [numericValue], type: BOOL, loc },
+                    then: numLit(0, loc), else_: { kind: "libCall", fn: "math.trunc", args: [numericValue], type: F64, loc }, type: F64, loc,
+                }, loc },
+        ];
+        if (method === "at") {
+            body.push({ kind: "if", cond: bin("<", position, numLit(0, loc)),
+                then: [{ kind: "assign", localId: "position.0", value: bin("+", position, length), loc }], else_: null, loc });
+        }
+        body.push({ kind: "if", cond: either(bin("<", position, numLit(0, loc)), bin(">=", position, length)),
+            then: [{ kind: "return", value: miss, loc }], else_: null, loc });
+        if (method === "at") {
+            body.push({ kind: "return", value: wrap({ kind: "strIntrinsic", method: "charAt", receiver: stringReceiver, args: [position], type: STRING, loc }), loc });
+        }
+        else {
+            body.push({ kind: "varDecl", localId: "first.0", init: { kind: "strIntrinsic", method: "charCodeAt", receiver: stringReceiver, args: [position], type: F64, loc }, loc });
+            body.push({ kind: "if", cond: either(either(bin("<", first, numLit(0xd800, loc)), bin(">", first, numLit(0xdbff, loc))), bin(">=", bin("+", position, numLit(1, loc)), length)),
+                then: [{ kind: "return", value: wrap(first), loc }], else_: null, loc });
+            body.push({ kind: "varDecl", localId: "second.0", init: { kind: "strIntrinsic", method: "charCodeAt", receiver: stringReceiver, args: [bin("+", position, numLit(1, loc))], type: F64, loc }, loc });
+            body.push({ kind: "if", cond: either(bin("<", second, numLit(0xdc00, loc)), bin(">", second, numLit(0xdfff, loc))),
+                then: [{ kind: "return", value: wrap(first), loc }], else_: null, loc });
+            body.push({ kind: "return", value: wrap(bin("+", bin("+", bin("*", bin("-", first, numLit(0xd800, loc)), numLit(1024, loc)), bin("-", second, numLit(0xdc00, loc))), numLit(0x10000, loc))), loc });
+        }
+        lowerer.liftedFns.push({
+            name: helper,
+            params: [{ localId: "arg.0", name: "receiver", type: receiver.type }, { localId: "arg.1", name: "index", type: index.type }],
+            returnType: resultType,
+            locals: [
+                { id: "arg.0", name: "receiver", type: receiver.type, mutable: false },
+                { id: "arg.1", name: "index", type: index.type, mutable: false },
+                { id: "receiver.0", name: "stringReceiver", type: STRING, mutable: false },
+                { id: "length.0", name: "length", type: F64, mutable: false },
+                { id: "numeric.0", name: "numeric", type: F64, mutable: false },
+                { id: "position.0", name: "position", type: F64, mutable: method === "at" },
+                ...(method === "codePointAt" ? [
+                    { id: "first.0", name: "first", type: F64, mutable: false },
+                    { id: "second.0", name: "second", type: F64, mutable: false },
+                ] : []),
+            ],
+            body, loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: [receiver, index], type: resultType, loc };
+}
+function paddingFillString(lowerer, value, node) {
+    const loc = value.loc;
+    if (value.type.kind === "undefinedT" || value.type.kind === "void")
+        return strLit(" ", loc);
+    if (value.type.kind === "nullT")
+        return strLit("null", loc);
+    if (value.type.kind === "dyn") {
+        return {
+            kind: "ternary",
+            cond: { kind: "dynTest", test: "undefined", value, type: BOOL, loc },
+            then: strLit(" ", loc),
+            else_: { kind: "libCall", fn: "dyn.toStringCoerce", args: [value], type: STRING, loc },
+            type: STRING, loc,
+        };
+    }
+    if (value.type.kind === "union") {
+        const unionId = value.type.unionId;
+        const arms = lowerer.unions.get(unionId).arms;
+        let result = strLit(" ", loc);
+        for (let tag = arms.length - 1; tag >= 0; tag--) {
+            const narrowed = { kind: "unionNarrow", unionId, tag, value, type: arms[tag], loc };
+            const converted = paddingFillString(lowerer, narrowed, node);
+            result = tag === arms.length - 1 ? converted : {
+                kind: "ternary",
+                cond: { kind: "unionIsTag", unionId, tag, value, negated: false, type: BOOL, loc },
+                then: converted, else_: result, type: STRING, loc,
+            };
+        }
+        return result;
+    }
+    return lowerer.ensureString(value, node);
+}
+/** Pad arguments are evaluated before receiver/length coercion, while fill
+ * conversion runs only if padding is needed. One helper keeps that order for
+ * member calls and direct String.prototype calls alike. */
+export function lowerStringPaddingCall(lowerer, call, method, receiver, receiverNode, argumentNodes) {
+    if (argumentNodes.length > 2) {
+        return lowerer.noLowering(`.${method} with ${argumentNodes.length} arguments`, call);
+    }
+    const loc = locOf(call);
+    const maxLength = lowerPositionArgument(lowerer, argumentNodes[0], numLit(0, loc));
+    const fillNode = argumentNodes[1];
+    const undefinedFill = fillNode ? lowerStaticallyUndefinedArgument(lowerer, fillNode) : null;
+    const rawFill = !fillNode ? strLit(" ", loc) : undefinedFill
+        ? defaultAfterUndefined(undefinedFill, strLit(" ", loc))
+        : lowerer.lowerExpr(fillNode);
+    const fill = rawFill.type.kind === "nullT"
+        ? defaultAfterUndefined(rawFill, strLit("null", loc)) : rawFill;
+    const values = [receiver, maxLength, fill];
+    const key = `str.pad:${method}:${values.map(value => typeKey(value.type)).join(":")}`;
+    let helper = lowerer.widthHelpers.get(key);
+    if (!helper) {
+        helper = `%str.pad.${lowerer.widthHelpers.size}`;
+        const params = values.map((value, index) => ({ localId: `arg.${index}`, name: `arg${index}`, type: value.type }));
+        const rawReceiver = varRef("arg.0", receiver.type, loc);
+        const convertedReceiver = receiver.type.kind === "dyn" ? {
+            kind: "ternary",
+            cond: { kind: "dynTest", test: "nullish", value: rawReceiver, type: BOOL, loc },
+            then: nodeThrowExpr(1, "", `String.prototype.${method} called on null or undefined`, STRING, loc),
+            else_: { kind: "libCall", fn: "dyn.toStringCoerce", args: [rawReceiver], type: STRING, loc },
+            type: STRING, loc,
+        } : lowerer.ensureString(rawReceiver, receiverNode);
+        const stringReceiver = varRef("receiver.0", STRING, loc);
+        const length = varRef("length.0", F64, loc);
+        const fillValue = varRef("arg.2", fill.type, loc);
+        const padded = {
+            kind: "strIntrinsic", method, receiver: stringReceiver,
+            args: [length, paddingFillString(lowerer, fillValue, fillNode ?? call)], type: STRING, loc,
+        };
+        const result = {
+            kind: "ternary",
+            cond: {
+                kind: "bin", op: ">=", left: length,
+                right: {
+                    kind: "bin", op: "+",
+                    left: { kind: "strIntrinsic", method: "length", receiver: stringReceiver, args: [], type: F64, loc },
+                    right: numLit(1, loc), type: F64, loc,
+                },
+                type: BOOL, loc,
+            },
+            then: padded, else_: stringReceiver, type: STRING, loc,
+        };
+        const body = [
+            { kind: "varDecl", localId: "receiver.0", init: convertedReceiver, loc },
+            { kind: "varDecl", localId: "length.0", init: positionNumber(lowerer, varRef("arg.1", maxLength.type, loc), numLit(0, loc), argumentNodes[0] ?? call, "string padding length"), loc },
+            { kind: "return", value: result, loc },
+        ];
+        lowerer.widthHelpers.set(key, helper);
+        lowerer.liftedFns.push({
+            name: helper, params, returnType: STRING,
+            locals: [
+                ...params.map(param => ({ id: param.localId, name: param.name, type: param.type, mutable: false })),
+                { id: "receiver.0", name: "receiver", type: STRING, mutable: false },
+                { id: "length.0", name: "length", type: F64, mutable: false },
+            ],
+            body, loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: values, type: STRING, loc };
+}
 /** Regex method calls, both directions: `re.test(s)` on a regex receiver,
  * and `s.replace(re, tpl)` / `s.replaceAll(re, tpl)` / `s.split(re)` on a
  * string receiver whose FIRST ARGUMENT is a regex (the string-pattern
@@ -52,6 +342,9 @@ export function lowerRegexMethodCall(lowerer, call, access, dynReceiver) {
     };
     const loc = locOf(call);
     if (receiverKind === "regex" && name === "test") {
+        if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement)) {
+            lowerer.noLowering("RegExp.prototype.test with surplus or spread arguments", call);
+        }
         // The statefulness fence, at compile time where the flags are
         // visible: a literal receiver (possibly parenthesized). Values that
         // flow through variables hit the same fence at runtime.
@@ -65,7 +358,7 @@ export function lowerRegexMethodCall(lowerer, call, access, dynReceiver) {
             }
         }
         const receiver = lowerReceiver();
-        const args = call.arguments.map((a) => lowerer.ensureString(lowerer.lowerExpr(a), a));
+        const args = [lowerRegexSubject(lowerer, call.arguments[0], loc)];
         return { kind: "regexIntrinsic", method: "test", receiver, args, type: BOOL, loc };
     }
     // `re.exec(s)` for non-g/y regexes: spec-identical to `s.match(re)`
@@ -76,8 +369,8 @@ export function lowerRegexMethodCall(lowerer, call, access, dynReceiver) {
     // compile time on literal receivers, exactly test()'s stance; values
     // reaching the runtime with those flags abort there.
     if (receiverKind === "regex" && name === "exec") {
-        if (call.arguments.length !== 1)
-            return null; // exec takes exactly the subject
+        if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement))
+            return null;
         let recv = access.expression;
         while (ts.isParenthesizedExpression(recv))
             recv = recv.expression;
@@ -88,9 +381,13 @@ export function lowerRegexMethodCall(lowerer, call, access, dynReceiver) {
             }
         }
         const re = lowerReceiver();
-        const subject = lowerer.lowerExprExpecting(call.arguments[0], STRING);
+        const subject = lowerRegexSubject(lowerer, call.arguments[0], loc);
         const resultT = { kind: "union", unionId: lowerer.unions.intern([arrayOf(STRING), { kind: "nullT" }]) };
-        return { kind: "regexIntrinsic", method: "match", receiver: subject, args: [re], type: resultT, loc };
+        // The shared match intrinsic takes the string first; preserve exec's
+        // receiver-before-subject evaluation order before swapping operands.
+        const saved = lowerer.declareHiddenLocal("%execReceiver", re.type);
+        const result = { kind: "regexIntrinsic", method: "match", receiver: subject, args: [varRef(saved.id, re.type, loc)], type: resultT, loc };
+        return { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: saved.id, init: re, loc }], result, type: resultT, loc };
     }
     // `s.match(re)` for non-g/y regexes: Node's exec-shaped result reduced
     // to the honest slice — the `string[] | null` union holding
@@ -212,18 +509,16 @@ export function lowerRegexMethodCall(lowerer, call, access, dynReceiver) {
     return null;
 }
 /** `s.slice(1, 4)` and friends → strIntrinsic. Null when this isn't an
- * ambient string method call (caller keeps its generic rejection). Missing
- * optional arguments are omitted from `args` — the backend fills the
- * documented defaults; the IR never encodes them (Infinity isn't
- * JSON-safe). tsc has already checked arity and argument types against
- * ambient/scriptc.d.ts. */
-export function lowerStringMethodCall(lowerer, call, access, dynReceiver) {
+ * ambient string method call (caller keeps its generic rejection).
+ * Complete position defaults and conversions here for both backends. */
+export function lowerStringMethodCall(lowerer, call, access, dynReceiver, argumentNodes = call.arguments) {
     if (lowerer.chainBlocked(access, call))
         return null;
     if (dynReceiver === undefined && access.name.text === "localeCompare")
         return lowerLocaleCompareCall(lowerer, call, access);
     const entry = own(STR_METHODS, access.name.text);
-    if (!entry)
+    const indexMethod = STRING_INDEX_METHODS.has(access.name.text) ? access.name.text : null;
+    if (!entry && !indexMethod)
         return null;
     // A validated dyn receiver (`pkg.name.replace(...)` on a JSON.parse
     // value) arrives pre-extracted through `dynReceiver`; its checker type
@@ -244,29 +539,120 @@ export function lowerStringMethodCall(lowerer, call, access, dynReceiver) {
         if (!lowerer.isStdlibMember(access))
             return null;
     }
-    // The lib declares optional parameters beyond the lowered forms
-    // (includes/startsWith/endsWith take a position); fence the unlowered
-    // arities instead of passing arguments the runtime doesn't take.
-    if (call.arguments.length < entry.minArgs || call.arguments.length > entry.maxArgs) {
-        lowerer.noLowering(`.${access.name.text} with ${call.arguments.length} argument${call.arguments.length === 1 ? "" : "s"} on strings`, call);
+    // The lib declares optional parameters beyond some lowered forms; fence
+    // those arities instead of passing arguments the runtime doesn't take.
+    if (argumentNodes.length < (entry?.minArgs ?? 0) || argumentNodes.length > (entry?.maxArgs ?? 1)) {
+        lowerer.noLowering(`.${access.name.text} with ${argumentNodes.length} argument${argumentNodes.length === 1 ? "" : "s"} on strings`, call);
     }
     const receiver = dynReceiver
         ? dynReceiver()
         : lowerMethodReceiver(lowerer, access.expression, STRING, access.name.text);
-    const args = entry.method === "split"
-        ? [lowerer.lowerExpr(call.arguments[0]), lowerSplitLimitArg(lowerer, call.arguments[1], locOf(call))]
-        : call.arguments.map((a) => lowerer.lowerExpr(a));
-    // split's separator must BE a string here (a regex argument was
-    // claimed by lowerRegexMethodCall before this path) — the lib's
-    // `string | RegExp` union has no lowering as a VALUE.
-    if (entry.method === "split" && args[0].type.kind !== "string") {
-        lowerer.unsupported("SC1090", call.arguments[0], `'.split()' on a '${lowerer.fmt(args[0].type)}' separator (pass a string, or a regex literal)`);
+    const loc = locOf(call);
+    if (indexMethod)
+        return lowerStringIndexCall(lowerer, call, indexMethod, receiver, access.expression, argumentNodes);
+    if (!entry)
+        return null;
+    if (entry.method === "split")
+        return lowerStringSplitCall(lowerer, call, receiver, access.expression, argumentNodes);
+    if (entry.method === "padStart" || entry.method === "padEnd") {
+        return lowerStringPaddingCall(lowerer, call, entry.method, receiver, access.expression, argumentNodes);
     }
-    // padStart/padEnd with the fill omitted: Node pads with " " — the
-    // same call with the default made explicit.
-    if ((entry.method === "padStart" || entry.method === "padEnd") && args.length === 1) {
-        args.push({ kind: "strLit", value: " ", type: STRING, loc: locOf(call) });
+    const searchMethod = entry.method === "indexOf" || entry.method === "includes" ||
+        entry.method === "startsWith" || entry.method === "endsWith";
+    if (searchMethod && argumentNodes.length < 2) {
+        const needle = lowerStringSearchArgument(lowerer, argumentNodes[0], loc);
+        return { kind: "strIntrinsic", method: entry.method, receiver, args: [needle], type: entry.result, loc };
+    }
+    if (searchMethod && argumentNodes.length === 2) {
+        const needleNode = argumentNodes[0];
+        const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, needleNode);
+        let needle = undefinedArg
+            ? defaultAfterUndefined(undefinedArg, strLit("undefined", loc))
+            : lowerer.lowerExpr(needleNode);
+        if (isUnitType(needle.type))
+            needle = coerceStringSearchValue(lowerer, needle, needleNode, loc);
+        const scalarUnion = needle.type.kind === "union" &&
+            (lowerer.unions.get(needle.type.unionId)?.arms.every((arm) => arm.kind === "string" || arm.kind === "f64" || arm.kind === "bool" || arm.kind === "bigint" || isUnitType(arm)) ?? false);
+        const scalarNeedle = needle.type.kind === "f64" || needle.type.kind === "bool" || needle.type.kind === "bigint" || scalarUnion;
+        if (needle.type.kind !== "string" && needle.type.kind !== "dyn" && !scalarNeedle) {
+            lowerer.noLowering(`.${entry.method} with '${lowerer.fmt(needle.type)}' search values`, call);
+        }
+        const defaultPosition = entry.method === "endsWith"
+            ? { kind: "bin", op: "/", left: numLit(1, loc), right: numLit(0, loc), type: F64, loc }
+            : numLit(0, loc);
+        const position = lowerPositionArgument(lowerer, argumentNodes[1], defaultPosition);
+        if (needle.type.kind === "string" && (position.type.kind === "f64" || position.type.kind === "jsval")) {
+            return { kind: "strIntrinsic", method: entry.method, receiver, args: [needle, position], type: entry.result, loc };
+        }
+        const key = `str.positions:${entry.method}:${typeKey(needle.type)}:${typeKey(position.type)}`;
+        let helper = lowerer.widthHelpers.get(key);
+        if (!helper) {
+            helper = `%str.positions.${lowerer.widthHelpers.size}`;
+            const params = [receiver, needle, position].map((arg, index) => ({ localId: `arg.${index}`, name: `arg${index}`, type: arg.type }));
+            const coerceNeedle = needle.type.kind !== "string";
+            const search = coerceNeedle ? varRef("search.0", STRING, loc) : varRef("arg.1", STRING, loc);
+            const result = {
+                kind: "strIntrinsic", method: entry.method, receiver: varRef("arg.0", STRING, loc),
+                args: [
+                    search,
+                    positionNumber(lowerer, varRef("arg.2", position.type, loc), defaultPosition, argumentNodes[1], "string position"),
+                ],
+                type: entry.result, loc,
+            };
+            const locals = params.map(param => ({ id: param.localId, name: param.name, type: param.type, mutable: false }));
+            const body = [];
+            if (coerceNeedle) {
+                const value = varRef("arg.1", needle.type, loc);
+                const init = needle.type.kind === "dyn"
+                    ? { kind: "libCall", fn: "dyn.toStringCoerce", args: [value], type: STRING, loc }
+                    : coerceStringSearchValue(lowerer, value, needleNode, loc);
+                locals.push({ id: "search.0", name: "search", type: STRING, mutable: false });
+                body.push({ kind: "varDecl", localId: "search.0", init, loc });
+            }
+            body.push({ kind: "return", value: result, loc });
+            lowerer.widthHelpers.set(key, helper);
+            lowerer.liftedFns.push({
+                name: helper, params, returnType: entry.result,
+                locals, body, loc,
+            });
+        }
+        return { kind: "call", callee: helper, args: [receiver, needle, position], type: entry.result, loc };
+    }
+    if (entry.method === "charAt" || entry.method === "charCodeAt" || entry.method === "slice" || entry.method === "substring" || entry.method === "repeat") {
+        const defaults = [numLit(0, loc)];
+        if (entry.method === "slice" || entry.method === "substring") {
+            defaults.push({ kind: "bin", op: "/", left: numLit(1, loc), right: numLit(0, loc), type: F64, loc });
+        }
+        const args = defaults.map((value, index) => lowerPositionArgument(lowerer, argumentNodes[index], value));
+        const subject = entry.method === "repeat" ? "string repeat count" : "string position";
+        // Keep ordinary numeric calls on the direct intrinsic path, including the
+        // existing boundary validation for island values in numeric slots.
+        if (args.every(arg => arg.type.kind === "f64" || arg.type.kind === "jsval")) {
+            return { kind: "strIntrinsic", method: entry.method, receiver, args, type: entry.result, loc };
+        }
+        // A helper evaluates all arguments before conversions can invoke hooks or
+        // throw. Its parameters also give owned strings/unions a per-call lifetime
+        // when the call occurs in a loop condition or short-circuit expression.
+        const key = `str.positions:${entry.method}:${args.map(arg => typeKey(arg.type)).join(":")}`;
+        let helper = lowerer.widthHelpers.get(key);
+        if (!helper) {
+            helper = `%str.positions.${lowerer.widthHelpers.size}`;
+            const params = [receiver, ...args].map((arg, index) => ({ localId: `arg.${index}`, name: `arg${index}`, type: arg.type }));
+            const result = {
+                kind: "strIntrinsic", method: entry.method, receiver: varRef("arg.0", STRING, loc),
+                args: args.map((arg, index) => positionNumber(lowerer, varRef(`arg.${index + 1}`, arg.type, loc), defaults[index], argumentNodes[index] ?? call, subject)),
+                type: entry.result, loc,
+            };
+            lowerer.widthHelpers.set(key, helper);
+            lowerer.liftedFns.push({
+                name: helper, params, returnType: entry.result,
+                locals: params.map(param => ({ id: param.localId, name: param.name, type: param.type, mutable: false })),
+                body: [{ kind: "return", value: result, loc }], loc,
+            });
+        }
+        return { kind: "call", callee: helper, args: [receiver, ...args], type: entry.result, loc };
     }
+    const args = argumentNodes.map((a) => lowerer.lowerExpr(a));
     return {
         kind: "strIntrinsic",
         method: entry.method,