@scriptc/compiler 0.1.4 → 0.1.6

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

@@ -164,10 +164,22 @@ export declare function lowerRecordKeyRead(lowerer: Lowerer, expr: ts.ElementAcc
  * around the read are erased here because this context handles the missing
  * arm instead of consuming it as the asserted type. */
 export declare function lowerAbsenceProbe(lowerer: Lowerer, node: ts.Expression): IrExpr | null;
+/** `a[i] op= rhs` over native arrays and byte views. A compound assignment
+ * evaluates the receiver and index, reads the old element, evaluates rhs,
+ * then writes. Capture each stage so a call in the index or rhs cannot
+ * change the target or the value used by the operator. The expression yields
+ * the computed value before a typed array or Buffer coerces it for storage. */
+export declare function lowerElementCompound(lowerer: Lowerer, expr: ts.BinaryExpression, op: CompoundOp): IrExpr;
 /** `a[i] = v` in statement position → arraySet (element writes, like local
    * assignment, produce no value in our subset). */
 export declare function lowerElementWrite(lowerer: Lowerer, expr: ts.BinaryExpression): IrStmt;
 export declare function ensureString(lowerer: Lowerer, e: IrExpr, node: ts.Node): IrExpr;
+/** `new String(x)` (stdlib provenance, ≤1 argument) in a ToString
+   * position: the wrapper's only distinguishers are typeof and identity —
+   * neither is observable where the value immediately stringifies — so the
+   * span lowers as the argument's own ToString (`new String()` is "").
+   * Every other position keeps the wrapper-object constructor fence. */
+export declare function stringWrapperToString(lowerer: Lowerer, node: ts.Expression): IrExpr | null;
 export declare function lowerTemplate(lowerer: Lowerer, expr: ts.TemplateExpression): IrExpr;
 /** `x as T`. Non-dyn inner values ordinarily erase; a record assertion
    * changing monomorphic shape rebuilds through the established width-copy

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

@@ -11,11 +11,12 @@ import { pathToFileURL } from "node:url";
 import { wasiGuestPath } from "../../wasi-paths.js";
 import { BIGINT_T, BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, JSVAL, NULL_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_ERROR_CLASSES, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, canAdaptDynFuncTo, canBoxFuncIntoDyn, funcOf, isDynTypedRefType, isJsonSafeType, isSupportedArrayElem, isUnitType, jsOpResultKind, shapeHasAccessorSlots, typeEquals, typeKey, unionFuncSetArmsOk } from "../../ir/ir.js";
 import { cjsClassExprWholeExportOf, cjsExportAssignmentOf, cjsExportDiscardReason, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeEsmFile, locOf } from "../program.js";
-import { ARRAY_METHODS, builtinConstLit, builtinFenceHintOf, builtinModuleConstOf, builtinModulesArrayLit, builtinModuleFnOf, ISLAND_SURFACE, isChildSurfaceMember, MAP_METHODS, NARROW_FIRST, SET_METHODS, STR_METHODS, UNSUPPORTED_EXPR, sideEffectFreeOptionValue, stdlibGlobalNameOf } from "./surfaces.js";
+import { ARRAY_METHODS, builtinConstLit, builtinFenceHintOf, builtinModuleConstOf, builtinModulesArrayLit, builtinModuleFnOf, COMPOUND_ASSIGN_OPS, ISLAND_SURFACE, isChildSurfaceMember, MAP_METHODS, NARROW_FIRST, SET_METHODS, STRING_INDEX_METHODS, STR_METHODS, UNSUPPORTED_EXPR, sideEffectFreeOptionValue, stdlibGlobalNameOf } from "./surfaces.js";
 import { blockedBindingUseDiag, requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
 import { PoisonError, dynUndefinedExpr, jsFuncNameOf, neverTaintedJsType, nodeThrowExpr, own } from "./lowerer.js";
-import { lowerNpmStaticSafeIndexRead, lowerSafeIndexRead, strCharsCall } from "./lower-containers.js";
-import { arrayValueStore } from "./array-values.js";
+import { lowerNpmStaticSafeIndexRead, lowerSafeIndexRead, strCharsCall, tryLowerNumericIndexRead } from "./lower-containers.js";
+import { arrayValueRead, arrayValueStore } from "./array-values.js";
+import { tryLowerIndexedComparison } from "./indexed-comparison.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
 import { unsupportedModuleFeatureOf } from "../builtin-modules.js";
 import { fenceEnumObjectValue, lowerEnumAccess } from "./lower-enums.js";
@@ -35,6 +36,7 @@ import { conditionalSpreadOf, foldedStringKeyOf } from "./expressions/object-lit
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { fenceNodeModuleMutation, isNodeModuleValue, lowerNodeModuleIdentifier, lowerNodeModuleProperty, lowerRequireCacheElement, lowerRequireCacheHas, lowerRequireMainProperty } from "./lower-node-module.js";
 import { lowerAbstractEquality } from "./abstract-equality.js";
+import { coerceStringSearchValue, defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optional-arguments.js";
 /** A template piece's RAW text (String.raw's contract: escapes stay
  * characters). 7's client AST ships no rawText at runtime (the typing
  * declares it; the serialized node data omits it), so the raw span comes
@@ -553,6 +555,18 @@ function lowerExprInner(lowerer, expr) {
             return { kind: "strLit", value: "object", type: STRING, loc };
         }
         if (ts.isPropertyAccessExpression(expr.expression)) {
+            const member = expr.expression;
+            const prototype = member.expression;
+            if (STRING_INDEX_METHODS.has(member.name.text) && ts.isPropertyAccessExpression(prototype) &&
+                prototype.name.text === "prototype" && ts.isIdentifier(prototype.expression) &&
+                lowerer.isStdlibGlobal(prototype.expression, "String") && lowerer.isStdlibMember(member)) {
+                return { kind: "strLit", value: "function", type: STRING, loc };
+            }
+            if (member.name.text === "at" && ts.isPropertyAccessExpression(prototype) &&
+                prototype.name.text === "prototype" && ts.isIdentifier(prototype.expression) &&
+                lowerer.isStdlibGlobal(prototype.expression, "Array") && lowerer.isStdlibMember(member)) {
+                return { kind: "strLit", value: "function", type: STRING, loc };
+            }
             const presence = lowerPromiseThenPresence(lowerer, expr.expression, { kind: "strLit", value: "function", type: STRING, loc });
             if (presence !== null)
                 return presence;
@@ -871,6 +885,12 @@ function lowerExprInner(lowerer, expr) {
                 if (bi.module === "module" && bi.member === "builtinModules") {
                     return builtinModulesArrayLit(loc);
                 }
+                if (bi.module === "http" && bi.member === "METHODS") {
+                    return { kind: "libCall", fn: "http.methods", args: [], type: arrayOf(STRING), loc };
+                }
+                if (bi.module === "http" && bi.member === "STATUS_CODES") {
+                    return { kind: "libCall", fn: "http.statusCodes", args: [], type: DYN, loc };
+                }
                 // tls.rootCertificates: a runtime-valued module constant (the
                 // cached bundled-CA array) — the one member read that lowers
                 // to a libCall instead of a baked literal.
@@ -3392,7 +3412,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
             : { kind: "arrIntrinsic", method: "length", receiver, args: [], type: F64, loc: locOf(expr) };
     }
     if (kind === "string"
-        ? own(STR_METHODS, name) !== undefined || own(ISLAND_SURFACE.string, name) !== undefined
+        ? own(STR_METHODS, name) !== undefined || STRING_INDEX_METHODS.has(name) || own(ISLAND_SURFACE.string, name) !== undefined
         : ARRAY_METHODS.has(name)) {
         lowerer.unsupported("SC1090", expr, `${kind} methods as values (call '${name}' directly)`);
     }
@@ -3804,6 +3824,11 @@ export function lowerOptionalNumber(lowerer, operand, loc, narrowedNode) {
     if (operand.type.kind !== "union" || lowerer.armTag(operand.type.unionId, UNDEFINED_T) < 0)
         return operand;
     const directNumber = lowerer.stripUndefinedArm(operand.type).kind === "f64";
+    if (directNumber) {
+        const scalarRead = tryLowerNumericIndexRead(lowerer, operand, loc);
+        if (scalarRead)
+            return scalarRead;
+    }
     const checkerNumber = narrowedNode !== undefined && lowerer.mapTypeOf(lowerer.typeOf(narrowedNode))?.kind === "f64";
     if (!directNumber && (!checkerNumber || lowerer.armTag(operand.type.unionId, F64) < 0))
         return operand;
@@ -4582,6 +4607,78 @@ function tupleLiteralIndex(node) {
     const n = Number(e.text);
     return Number.isInteger(n) && n >= 0 ? n : null;
 }
+/** `a[i] op= rhs` over native arrays and byte views. A compound assignment
+ * evaluates the receiver and index, reads the old element, evaluates rhs,
+ * then writes. Capture each stage so a call in the index or rhs cannot
+ * change the target or the value used by the operator. The expression yields
+ * the computed value before a typed array or Buffer coerces it for storage. */
+export function lowerElementCompound(lowerer, expr, op) {
+    const target = expr.left;
+    fenceNodeModuleMutation(lowerer, target, "assignment");
+    const loc = locOf(expr);
+    const receiverType = lowerer.mapTypeOf(lowerer.typeOf(target.expression));
+    if (receiverType?.kind !== "array" && receiverType?.kind !== "bytes") {
+        lowerer.unsupported("SC1090", target, "compound assignment to non-array elements");
+    }
+    let receiver = lowerer.lowerExpr(target.expression);
+    if (receiver.type.kind === "union" && lowerer.armTag(receiver.type.unionId, UNDEFINED_T) >= 0) {
+        const present = lowerer.stripUndefinedArm(receiver.type);
+        const helper = present.kind === receiverType.kind
+            ? lowerer.narrowedArmHelper(receiver.type.unionId, present, locOf(target.expression))
+            : null;
+        if (helper)
+            receiver = { kind: "call", callee: helper, args: [receiver], type: present, loc: locOf(target.expression) };
+    }
+    if (receiver.type.kind !== receiverType.kind) {
+        lowerer.unsupported("SC1090", target.expression, "compound assignment through a non-native array or byte view");
+    }
+    const index = lowerer.lowerExpr(target.argumentExpression);
+    if (index.type.kind !== "f64")
+        lowerer.unsupported("SC1090", target.argumentExpression, "indexing with non-number keys");
+    const receiverLocal = lowerer.declareHiddenLocal("%compoundArray", receiver.type);
+    const indexLocal = lowerer.declareHiddenLocal("%compoundIndex", F64);
+    const receiverRef = () => varRef(receiverLocal.id, receiver.type, loc);
+    const indexRef = () => varRef(indexLocal.id, F64, loc);
+    const oldValue = receiver.type.kind === "array"
+        ? arrayValueRead(lowerer, receiverRef(), indexRef(), receiver.type.elem, locOf(target))
+        : { kind: "bytesIntrinsic", method: "get", receiver: receiverRef(), args: [indexRef()], type: F64, loc: locOf(target) };
+    const oldLocal = lowerer.declareHiddenLocal("%compoundOld", oldValue.type);
+    const oldRef = () => varRef(oldLocal.id, oldValue.type, loc);
+    const rhs = lowerer.lowerExpr(expr.right);
+    const numericRhs = lowerOptionalNumber(lowerer, rhs, loc);
+    const elementType = receiver.type.kind === "array" ? receiver.type.elem : F64;
+    const valueType = elementType.kind === "union" && lowerer.armTag(elementType.unionId, UNDEFINED_T) >= 0
+        ? lowerer.stripUndefinedArm(elementType)
+        : elementType;
+    let computed;
+    if (op === "+" && valueType.kind === "string") {
+        computed = { kind: "strConcat", left: lowerer.ensureString(oldRef(), target), right: lowerer.ensureString(rhs, expr.right), type: STRING, loc };
+    }
+    else if (valueType.kind === "f64" && numericRhs.type.kind === "f64") {
+        computed = { kind: "bin", op, left: lowerOptionalNumber(lowerer, oldRef(), loc), right: numericRhs, type: F64, loc };
+    }
+    else {
+        lowerer.unsupported("SC1043", expr);
+    }
+    const resultLocal = lowerer.declareHiddenLocal("%compoundResult", computed.type);
+    const resultRef = () => varRef(resultLocal.id, computed.type, loc);
+    const write = receiver.type.kind === "array"
+        ? arrayValueStore(lowerer, receiverRef(), indexRef(), resultRef(), receiver.type.elem, loc)
+        : { kind: "bytesSet", arr: receiverRef(), index: indexRef(), value: resultRef(), loc };
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc },
+            { kind: "varDecl", localId: indexLocal.id, init: index, loc },
+            { kind: "varDecl", localId: oldLocal.id, init: oldValue, loc },
+            { kind: "varDecl", localId: resultLocal.id, init: computed, loc },
+            write,
+        ],
+        result: resultRef(),
+        type: computed.type,
+        loc,
+    };
+}
 /** `a[i] = v` in statement position → arraySet (element writes, like local
    * assignment, produce no value in our subset). */
 export function lowerElementWrite(lowerer, expr) {
@@ -4953,6 +5050,18 @@ export function ensureString(lowerer, e, node) {
         if (stringable) {
             return { kind: "toString", operand: e, type: STRING, loc: e.loc };
         }
+        // Runtime-optional locals can retain their stored union after the
+        // checker has narrowed this use to a primitive arm. Validate that
+        // arm before converting it; an unguarded object arm stays fenced.
+        const narrowed = lowerer.mapTypeOf(lowerer.typeOf(node));
+        if (narrowed &&
+            (narrowed.kind === "string" || narrowed.kind === "f64" ||
+                narrowed.kind === "bool" || narrowed.kind === "bigint")) {
+            const helper = lowerer.narrowedArmHelper(e.type.unionId, narrowed, e.loc);
+            if (helper) {
+                return ensureString(lowerer, { kind: "call", callee: helper, args: [e], type: narrowed, loc: e.loc }, node);
+            }
+        }
         lowerer.unsupported("SC1090", node, `string conversions of unions with object arms (${NARROW_FIRST})`);
     }
     if (e.type.kind === "symbol") {
@@ -5004,7 +5113,7 @@ export function ensureString(lowerer, e, node) {
    * neither is observable where the value immediately stringifies — so the
    * span lowers as the argument's own ToString (`new String()` is "").
    * Every other position keeps the wrapper-object constructor fence. */
-function stringWrapperToString(lowerer, node) {
+export function stringWrapperToString(lowerer, node) {
     let e = node;
     while (ts.isParenthesizedExpression(e))
         e = e.expression;
@@ -5018,7 +5127,11 @@ function stringWrapperToString(lowerer, node) {
         return null;
     if (args.length === 0)
         return { kind: "strLit", value: "", type: STRING, loc: locOf(e) };
-    return lowerer.caughtToString(args[0]) ?? lowerer.ensureString(lowerer.lowerExpr(args[0]), args[0]);
+    const undefinedArg = lowerStaticallyUndefinedArgument(lowerer, args[0]);
+    if (undefinedArg)
+        return defaultAfterUndefined(undefinedArg, { kind: "strLit", value: "undefined", type: STRING, loc: locOf(e) });
+    return lowerer.caughtToString(args[0]) ??
+        coerceStringSearchValue(lowerer, lowerer.lowerExpr(args[0]), args[0], locOf(e));
 }
 export function lowerTemplate(lowerer, expr) {
     const loc = locOf(expr);
@@ -5410,8 +5523,9 @@ export function lowerBinary(lowerer, expr) {
         // globals, captured/boxed included); the RHS coerces into the binding's
         // type exactly like statement position, and the expression's value is
         // the coerced binding-typed value (representation change only — never
-        // observably different from JS's raw-RHS yield). Compound operators,
-        // property/element targets, and destructuring targets stay fenced.
+        // observably different from JS's raw-RHS yield). Indexed compounds
+        // use a sequenced read/modify/write; other member targets and
+        // destructuring targets stay fenced.
         if (op === ts.SyntaxKind.EqualsToken && ts.isIdentifier(expr.left)) {
             const target = lowerer.resolveWritable(expr.left);
             if (!target) {
@@ -5423,6 +5537,10 @@ export function lowerBinary(lowerer, expr) {
                 lowerer.runtimeOptionalLocals.add(runtimeOptionalRoot);
             return { kind: "assignExpr", localId: target.id, value, type: target.type, loc };
         }
+        const indexedCompound = COMPOUND_ASSIGN_OPS[op];
+        if (indexedCompound !== undefined && ts.isElementAccessExpression(expr.left)) {
+            return lowerElementCompound(lowerer, expr, indexedCompound);
+        }
         // `events.defaultMaxListeners = v` — the module-property write
         // Node validates (validateNumber(n, 'defaultMaxListeners', 0)):
         // the value crosses into the checked-dynamic tree and the runtime ladder throws
@@ -6171,6 +6289,9 @@ export function lowerBinary(lowerer, expr) {
         case ts.SyntaxKind.EqualsEqualsEqualsToken:
         case ts.SyntaxKind.ExclamationEqualsEqualsToken: {
             const negated = op === ts.SyntaxKind.ExclamationEqualsEqualsToken;
+            const indexed = tryLowerIndexedComparison(lowerer, left, right, negated, loc);
+            if (indexed)
+                return indexed;
             if (plainBothNum)
                 return { kind: "bin", op: negated ? "!==" : "===", left, right, type: BOOL, loc };
             if (bothStr)
@@ -8739,7 +8860,20 @@ export function fieldGetExpr(lowerer, target, loc, blame) {
     // construction), typed as the index value armed with undefined under
     // noUncheckedIndexedAccess (mirroring lowerRecordKeyRead).
     if (target.container === "recordOvf") {
-        let t = target.fieldType;
+        let obj = target.obj;
+        if (obj.type.kind === "union" && ts.isPropertyAccessExpression(blame)) {
+            const present = lowerer.stripUndefinedArm(obj.type);
+            if (present.kind === "record") {
+                obj = lowerer.runtimeOptionalPropertyReceiver(blame.expression, obj, present, target.field) ?? obj;
+            }
+        }
+        if (obj.type.kind !== "record") {
+            lowerer.unsupported("SC1090", blame, `reading '${target.field}' on a non-record receiver (narrow first)`);
+        }
+        const shape = lowerer.shapes.get(obj.type.shapeId);
+        if (!shape?.indexValue)
+            lowerer.unsupported("SC1090", blame, `reading '${target.field}' on a record without an index signature`);
+        let t = shape.indexValue;
         if (lowerer.program.getCompilerOptions().noUncheckedIndexedAccess) {
             const armed = lowerer.withUndefinedArmOf(t);
             if (!armed)
@@ -8748,8 +8882,8 @@ export function fieldGetExpr(lowerer, target, loc, blame) {
         }
         return {
             kind: "recordKeyGet",
-            obj: target.obj,
-            shapeId: target.shapeId,
+            obj,
+            shapeId: obj.type.shapeId,
             key: { kind: "strLit", value: target.field, type: STRING, loc },
             overflowOnly: true,
             type: t,