@scriptc/compiler 0.4.6 → 0.4.8

package/dist/frontend/lowering/partial-assertions.js

@@ -0,0 +1,189 @@
+/* Partial record assertions (`{ truncated: true } as TruncationResult`).
+ *
+ * A record literal carries exactly the fields it writes, but its asserted
+ * type may require more. Node erases the assertion: the value keeps the
+ * literal's properties, and reading a field it never had yields undefined.
+ * A record type has a fixed layout, so scriptc keeps the LITERAL's layout
+ * (shape A — the written fields and the asserted type's optional fields,
+ * these in their absent state, with the asserted type's field types) and
+ * hands the asserted type B a PARTIAL record view of it (record-views.ts):
+ * the value is a B whose record-source entry names A, and the required B
+ * fields A does not declare are absent. Reflection through the view is
+ * exact, and a write to one of those fields adds the property to the view
+ * (the viewed record's extra-property store), so a program that fills a
+ * record literal field by field ends with every field it wrote.
+ *
+ * This module finds those sites and answers, per target shape, which
+ * required fields some asserted literal leaves unwritten. The lowering
+ * consults it for member reads and `in`, so a read of a field nothing wrote
+ * throws the catchable TypeError (Node yields undefined — a documented
+ * divergence) instead of reaching a slot the view does not have. Computed
+ * once for the whole program, on first use, like the untyped-collection
+ * inference (js-collection-types.ts). */
+import * as ts from "../ts7/adapter.js";
+import { isJsSourceFile, locOf } from "../program.js";
+import { nodeThrowExpr } from "../../ir/build.js";
+import { BOOL, DYN, UNDEFINED_T } from "../../ir/ir.js";
+const NO_FIELDS = new Set();
+/** The required fields some asserted literal leaves unwritten on shapes of
+ * `shapeId`; empty when no partial assertion produces that shape. */
+export function partialAssertionFields(lowerer, shapeId) {
+    return partialTargetOf(lowerer, shapeId)?.missing ?? NO_FIELDS;
+}
+function partialTargetOf(lowerer, shapeId) {
+    if (lowerer.partialAssertions === undefined) {
+        const found = new Map();
+        lowerer.partialAssertions = found;
+        for (const file of lowerer.program.getImplementationSourceFiles()) {
+            if (isJsSourceFile(file))
+                continue;
+            ts.walkPreorder(file, (node) => {
+                if (!ts.isAsExpression(node) && !ts.isTypeAssertion(node))
+                    return;
+                const site = partialAssertionSite(lowerer, node);
+                if (site === null)
+                    return;
+                const known = found.get(site.target.shapeId);
+                const missing = new Set();
+                if (known !== undefined) {
+                    for (const name of known.missing)
+                        missing.add(name);
+                }
+                for (const name of site.missing)
+                    missing.add(name);
+                found.set(site.target.shapeId, { missing, text: site.text });
+            });
+        }
+    }
+    return lowerer.partialAssertions.get(shapeId) ?? null;
+}
+/** The partial-assertion facts of `expr`, or null when it asserts a record
+ * literal to a type that needs no partial view. */
+export function partialAssertionSite(lowerer, expr) {
+    let operand = expr.expression;
+    while (ts.isParenthesizedExpression(operand))
+        operand = operand.expression;
+    if (!ts.isObjectLiteralExpression(operand))
+        return null;
+    const literal = operand;
+    const keys = [];
+    for (const prop of literal.properties.nodes) {
+        if (!ts.isShorthandPropertyAssignment(prop) && !ts.isPropertyAssignment(prop))
+            return null;
+        const name = prop.name;
+        if (!ts.isIdentifier(name) && !ts.isStringLiteral(name))
+            return null;
+        // A repeated key is the last write's; the literal alone would not
+        // decide the shape. Keys ride the literal's own inferred shape.
+        if (keys.includes(name.text))
+            return null;
+        keys.push(name.text);
+    }
+    const targetTs = lowerer.checker.getTypeFromTypeNode(expr.type);
+    const target = lowerer.mapTypeOf(targetTs);
+    if (target?.kind !== "record")
+        return null;
+    const shape = lowerer.shapes.get(target.shapeId);
+    if (!shape || shape.tuple || shape.indexValue !== undefined)
+        return null;
+    const missing = new Set();
+    for (const key of keys) {
+        // A key the asserted type does not declare would ride the overflow
+        // map, which a view has no slots for.
+        if (!shape.fields.some((f) => f.name === key))
+            return null;
+    }
+    const absent = [];
+    for (const field of shape.fields) {
+        if (keys.includes(field.name))
+            continue;
+        // An omitted optional field keeps a slot in the literal's layout, in its
+        // absent state (lowerPartialAssertion), as an ordinary record of the
+        // asserted type does: reads yield undefined, `in` answers false and a
+        // write adds the property. Only a required field can be missing.
+        if (field.type.kind === "union" && lowerer.armTag(field.type.unionId, UNDEFINED_T) >= 0) {
+            absent.push(field.name);
+            continue;
+        }
+        missing.add(field.name);
+    }
+    if (missing.size === 0)
+        return null;
+    return { target, keys, absent, missing, text: lowerer.checker.typeToString(targetTs) };
+}
+/** The checked read of `field` through a value of `shapeId` that a partial
+ * assertion may have produced, or null when the field is always present.
+ * `obj` is read twice (the presence test and the read), so it must be safe
+ * to repeat. */
+export function partialFieldRead(lowerer, obj, shapeId, field, fieldType, loc) {
+    const target = partialTargetOf(lowerer, shapeId);
+    if (target === null || !target.missing.has(field))
+        return null;
+    return {
+        kind: "ternary",
+        cond: { kind: "recordHas", obj, shapeId, field, type: BOOL, loc },
+        then: { kind: "recordGet", obj, shapeId, field, type: fieldType, loc },
+        else_: nodeThrowExpr(1, "", `Cannot read property '${field}': the object asserted as '${target.text}' has no such property`, fieldType, loc),
+        type: fieldType,
+        loc,
+    };
+}
+/** The own-property presence test for `field` on a receiver of `shapeId`
+ * (`"f" in value`), or null when no partial assertion can leave it absent.
+ * `obj` must be safe to repeat. */
+export function partialFieldPresence(lowerer, obj, shapeId, field, loc) {
+    const target = partialTargetOf(lowerer, shapeId);
+    if (target === null || !target.missing.has(field))
+        return null;
+    return { kind: "recordHas", obj, shapeId, field, type: BOOL, loc };
+}
+/** The checked conversion a partial assertion lowers to: the literal built
+ * at its OWN layout A (the asserted type's field types, values checked
+ * against them), boxed live, and asserted to B as a partial view. */
+export function lowerPartialAssertion(lowerer, expr, site) {
+    const loc = locOf(expr);
+    let literal = expr.expression;
+    while (ts.isParenthesizedExpression(literal))
+        literal = literal.expression;
+    const shape = lowerer.shapes.get(site.target.shapeId);
+    // The site check accepted exactly the literal's property assignments and
+    // shorthands, in source order.
+    const props = literal.properties.nodes;
+    const fields = site.keys.map((key, i) => {
+        const prop = props[i];
+        const initializer = ts.isPropertyAssignment(prop)
+            ? prop.initializer
+            : prop.name;
+        const type = shape.fields.find((f) => f.name === key).type;
+        const value = lowerer.coerceInto(prop, lowerer.lowerExprExpecting(initializer, type), type);
+        return { name: key, type, value };
+    });
+    for (const name of site.absent) {
+        const type = shape.fields.find((f) => f.name === name).type;
+        fields.push({
+            name,
+            type,
+            value: { kind: "fieldAbsent", unionId: type.unionId, type, loc },
+        });
+    }
+    // A's identity is its name-sorted field list; its DECLARED order is the
+    // literal's, which JSON and Object.keys read through the view's capsule,
+    // then the absent optional fields, which a later write appends.
+    const shapeId = lowerer.shapes.intern([...fields]
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+        .map((f) => ({ name: f.name, type: f.type })), false, undefined, [...site.keys, ...site.absent]);
+    const built = {
+        kind: "recordLit",
+        fields: fields.map((f) => ({ name: f.name, value: f.value })),
+        type: { kind: "record", shapeId },
+        loc,
+    };
+    return {
+        kind: "dynCheck",
+        partialView: true,
+        value: { kind: "dynFrom", value: built, liveRef: true, type: DYN, loc },
+        type: site.target,
+        loc,
+    };
+}
+//# sourceMappingURL=partial-assertions.js.map

package/dist/frontend/lowering/partial-assertions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partial-assertions.js","sourceRoot":"","sources":["../../../src/frontend/lowering/partial-assertions.ts"],"names":[],"mappings":"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"}

package/dist/frontend/lowering/primitive-throws.d.ts

@@ -0,0 +1,100 @@
+/** Node's TypeErrors for an operation that needs an OBJECT and receives a
+ * primitive — the `in` operator's ToObject, `new`'s IsConstructor,
+ * `delete`'s ToObject, and a member read's RequireObjectCoercible.
+ * JavaScript admits every one of these on a primitive (and the relaxed
+ * JavaScript diagnostics admit the source), so the code must run and throw
+ * exactly what V8 throws, not a lowering fence.
+ *
+ * Every message is built from the operand's own spelling, which is why the
+ * text is a runtime expression here rather than the literal
+ * `nodeThrowExpr` takes. */
+import * as ts from "../ts7/adapter.js";
+import { type IrExpr, type IrStmt, type IrType, type SrcLoc } from "../../ir/ir.js";
+import type { Lowerer } from "./lowerer.js";
+/** IR types whose JS value is a primitive: no own or inherited properties,
+ * so a property read, `in`, or `delete` coerces it — and `in` throws.
+ * `void` is the return position of a call, whose value at run time is
+ * undefined. */
+export declare function isPrimitiveValueType(t: IrType): boolean;
+/** The operand's spelling in a can't-coerce TypeError: units are literal,
+ * and every other primitive renders exactly as String() renders it (the
+ * object protocol never runs for a primitive, so the String constructor
+ * lowers to the same text V8 writes). */
+export declare function primitiveText(lowerer: Lowerer, value: IrExpr, loc: SrcLoc): IrExpr;
+/** An always-throwing Node TypeError whose message is computed at run time.
+ * `type` is the replaced expression's own type (never materialized). */
+export declare function throwTypeError(message: IrExpr, type: IrType, loc: SrcLoc): IrExpr;
+/** `Cannot use 'in' operator to search for '<key>' in <String(recv)>` — the
+ * `in` operator's ToObject refusal, also spelled by Reflect.has's
+ * non-object target check (which uses its own fixed message). */
+export declare function inOperatorTypeError(lowerer: Lowerer, key: string, recv: IrExpr, type: IrType, loc: SrcLoc): IrExpr;
+/** `delete`'s ToObject refusal: Node names neither the property nor the
+ * receiver here (`delete (null).x` and `delete (null)[k]` both throw it). */
+export declare function deleteToObjectTypeError(type: IrType, loc: SrcLoc): IrExpr;
+/** `null`/`undefined` when the expression IS one of them by construction —
+ * the `null` keyword, `void <expr>`, or the global `undefined` (the checker
+ * confirms the name still denotes the unit, since JavaScript may shadow it)
+ * — else null. Used where a member read happens before the receiver is
+ * lowered, so the test cannot disturb the lowering that follows. A binding
+ * or a property does NOT qualify even when the checker types it as a unit:
+ * a JavaScript property keeps its initializer's type through a later
+ * assignment, so its value has to answer, and the runtime read already
+ * throws the same TypeError in the same order. */
+export declare function nullishLiteral(lowerer: Lowerer, node: ts.Expression): "null" | "undefined" | null;
+/** True when the CHECKER types an expression as a primitive — a unit or any
+ * other primitive, or a union of them — and not as `any`/`unknown`, whose
+ * value the lowering cannot know. `new` uses it to choose the runtime
+ * primitive check for a callee that lowers to a dynamic slot (a JavaScript
+ * `const n = null` binding): an `any` callee keeps the runtime's own
+ * refusal, so the typed programs pay nothing for this branch. */
+export declare function staticallyPrimitive(lowerer: Lowerer, node: ts.Expression): boolean;
+/** `Cannot read properties of <unit> (reading '<name>')` — the member read
+ * a nullish receiver refuses, also what a call on such a member throws
+ * before its arguments evaluate. */
+export declare function nullishReadTypeError(unit: "null" | "undefined", name: string, type: IrType, loc: SrcLoc): IrExpr;
+/** A builtin identity token, which is NOT a primitive the program can
+ * observe. The identifier chokepoint represents a JavaScript source's
+ * unsupported builtin value (`import { AsyncResource } from
+ * "node:async_hooks"`) as an IR string whose text Node never produces, so
+ * identity flows (`===`, Set membership) agree between spellings. The
+ * object-coercion lowerings throw Node's TypeError for a primitive and
+ * spell it from the value, which for a token would report the carrier as if
+ * the program could see it ("AsyncResource is not a constructor" for a
+ * class Node constructs), so those branches leave the site to the
+ * reference's own fence instead.
+ *
+ * A token is recognized by its interned TEXT, not by its type alone: a
+ * program's own string casts to `any` as readily as an unsupported builtin
+ * export does, and `new ("hello" as any)()` is a Node TypeError to run, not
+ * a lowering fence. The checker test stays as a second condition, so a
+ * string the checker types as a string keeps its Node answer even when it
+ * spells a token. */
+export declare function isBuiltinIdentityToken(lowerer: Lowerer, node: ts.Expression, value: IrExpr): boolean;
+/** The statements that evaluate `expr` for its effects alone. A value the
+ * IR cannot spell (a unit — JavaScript's null/undefined has no standalone
+ * runtime value, so a bare unit literal fails validation) contributes only
+ * the statements its sequence kept, and a plain unit literal none at all. */
+export declare function effectStmts(expr: IrExpr, loc: SrcLoc): IrStmt[];
+/** `thrown`, preceded by the evaluation of `values` in order — the shape of
+ * every object-coercion refusal whose operands still have to run before the
+ * throw (`(recordedKey() in nullishReceiver())`). */
+export declare function throwAfterEach(values: readonly IrExpr[], thrown: IrExpr, loc: SrcLoc): IrExpr;
+/** Expression-position `delete` (`const ok = delete x.y`). Every receiver but
+ * a primitive keeps the statement-position-only fence. */
+export declare function lowerDeleteExpression(lowerer: Lowerer, expr: ts.DeleteExpression): IrExpr;
+/** `delete` on a primitive base, whose ToObject step gives the answer. The
+ * base evaluates first, then the key:
+ *
+ * - a nullish base throws Node's ToObject TypeError before the key's
+ *   ToPropertyKey, so the key runs without converting (and, through `?.`,
+ *   the chain short-circuits instead: the answer is `true` and the key
+ *   never runs);
+ * - any other primitive deletes from the ToObject wrapper. A String
+ *   wrapper carries its indexes and `length` as non-configurable own
+ *   properties, so deleting one answers `false` in sloppy code and throws
+ *   the TypeError in strict code, while every other primitive's wrapper
+ *   owns nothing. The runtime does the ToPropertyKey, which preserves a
+ *   Symbol key.
+ *
+ * `resultType` is the replaced expression's own type (never materialized). */
+export declare function lowerPrimitiveBaseDelete(lowerer: Lowerer, expr: ts.DeleteExpression, target: ts.PropertyAccessExpression | ts.ElementAccessExpression, obj: IrExpr, resultType: IrType): IrExpr;

package/dist/frontend/lowering/primitive-throws.js

@@ -0,0 +1,241 @@
+/** Node's TypeErrors for an operation that needs an OBJECT and receives a
+ * primitive — the `in` operator's ToObject, `new`'s IsConstructor,
+ * `delete`'s ToObject, and a member read's RequireObjectCoercible.
+ * JavaScript admits every one of these on a primitive (and the relaxed
+ * JavaScript diagnostics admit the source), so the code must run and throw
+ * exactly what V8 throws, not a lowering fence.
+ *
+ * Every message is built from the operand's own spelling, which is why the
+ * text is a runtime expression here rather than the literal
+ * `nodeThrowExpr` takes. */
+import * as ts from "../ts7/adapter.js";
+import { BOOL, DYN, STRING, isUnitType, } from "../../ir/ir.js";
+import { numLit, strLit } from "../../ir/build.js";
+import { locOf } from "../program.js";
+import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
+import { isStrictCode } from "./strict-mode.js";
+/** IR types whose JS value is a primitive: no own or inherited properties,
+ * so a property read, `in`, or `delete` coerces it — and `in` throws.
+ * `void` is the return position of a call, whose value at run time is
+ * undefined. */
+export function isPrimitiveValueType(t) {
+    switch (t.kind) {
+        case "nullT":
+        case "undefinedT":
+        case "void":
+        case "bool":
+        case "f64":
+        case "bigint":
+        case "string":
+        case "symbol":
+            return true;
+        default:
+            return false;
+    }
+}
+/** The operand's spelling in a can't-coerce TypeError: units are literal,
+ * and every other primitive renders exactly as String() renders it (the
+ * object protocol never runs for a primitive, so the String constructor
+ * lowers to the same text V8 writes). */
+export function primitiveText(lowerer, value, loc) {
+    if (isUnitType(value.type)) {
+        return strLit(value.type.kind === "nullT" ? "null" : "undefined", loc);
+    }
+    return {
+        kind: "libCall",
+        fn: "dyn.stringConstructor",
+        args: [lowerer.coerceToExpected(value, DYN)],
+        type: STRING,
+        loc,
+    };
+}
+/** An always-throwing Node TypeError whose message is computed at run time.
+ * `type` is the replaced expression's own type (never materialized). */
+export function throwTypeError(message, type, loc) {
+    return {
+        kind: "libCall",
+        fn: "error.nodeThrow",
+        args: [numLit(1, loc), strLit("", loc), message],
+        type,
+        loc,
+    };
+}
+/** `Cannot use 'in' operator to search for '<key>' in <String(recv)>` — the
+ * `in` operator's ToObject refusal, also spelled by Reflect.has's
+ * non-object target check (which uses its own fixed message). */
+export function inOperatorTypeError(lowerer, key, recv, type, loc) {
+    return throwTypeError({
+        kind: "strConcat",
+        left: strLit(`Cannot use 'in' operator to search for '${key}' in `, loc),
+        right: primitiveText(lowerer, recv, loc),
+        type: STRING,
+        loc,
+    }, type, loc);
+}
+/** `delete`'s ToObject refusal: Node names neither the property nor the
+ * receiver here (`delete (null).x` and `delete (null)[k]` both throw it). */
+export function deleteToObjectTypeError(type, loc) {
+    return throwTypeError(strLit("Cannot convert undefined or null to object", loc), type, loc);
+}
+/** `null`/`undefined` when the expression IS one of them by construction —
+ * the `null` keyword, `void <expr>`, or the global `undefined` (the checker
+ * confirms the name still denotes the unit, since JavaScript may shadow it)
+ * — else null. Used where a member read happens before the receiver is
+ * lowered, so the test cannot disturb the lowering that follows. A binding
+ * or a property does NOT qualify even when the checker types it as a unit:
+ * a JavaScript property keeps its initializer's type through a later
+ * assignment, so its value has to answer, and the runtime read already
+ * throws the same TypeError in the same order. */
+export function nullishLiteral(lowerer, node) {
+    let expr = node;
+    while (ts.isParenthesizedExpression(expr))
+        expr = expr.expression;
+    if (expr.kind === ts.SyntaxKind.NullKeyword)
+        return "null";
+    if (ts.isVoidExpression(expr))
+        return "undefined";
+    if (!ts.isIdentifier(expr) || expr.text !== "undefined")
+        return null;
+    const flags = lowerer.typeOf(expr).flags;
+    return flags & ts.TypeFlags.Undefined ? "undefined" : null;
+}
+/** True when the CHECKER types an expression as a primitive — a unit or any
+ * other primitive, or a union of them — and not as `any`/`unknown`, whose
+ * value the lowering cannot know. `new` uses it to choose the runtime
+ * primitive check for a callee that lowers to a dynamic slot (a JavaScript
+ * `const n = null` binding): an `any` callee keeps the runtime's own
+ * refusal, so the typed programs pay nothing for this branch. */
+export function staticallyPrimitive(lowerer, node) {
+    const { flags } = lowerer.typeOf(node);
+    if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown))
+        return false;
+    // A union answers through its arms, which the caller's IR types cover.
+    return ((flags &
+        (ts.TypeFlags.Null |
+            ts.TypeFlags.Undefined |
+            ts.TypeFlags.Void |
+            ts.TypeFlags.BooleanLike |
+            ts.TypeFlags.NumberLike |
+            ts.TypeFlags.BigIntLike |
+            ts.TypeFlags.StringLike |
+            ts.TypeFlags.ESSymbolLike)) !==
+        0);
+}
+/** `Cannot read properties of <unit> (reading '<name>')` — the member read
+ * a nullish receiver refuses, also what a call on such a member throws
+ * before its arguments evaluate. */
+export function nullishReadTypeError(unit, name, type, loc) {
+    return throwTypeError(strLit(`Cannot read properties of ${unit} (reading '${name}')`, loc), type, loc);
+}
+/** The text every builtin identity token carries: the identifier chokepoint
+ * and the JavaScript destructuring rule intern `[builtin <name>]`
+ * (identifiers.ts, property-access.ts, global-values.ts, lower-stmts.ts). */
+const BUILTIN_TOKEN_PREFIX = "[builtin ";
+const BUILTIN_TOKEN_SUFFIX = "]";
+/** A builtin identity token, which is NOT a primitive the program can
+ * observe. The identifier chokepoint represents a JavaScript source's
+ * unsupported builtin value (`import { AsyncResource } from
+ * "node:async_hooks"`) as an IR string whose text Node never produces, so
+ * identity flows (`===`, Set membership) agree between spellings. The
+ * object-coercion lowerings throw Node's TypeError for a primitive and
+ * spell it from the value, which for a token would report the carrier as if
+ * the program could see it ("AsyncResource is not a constructor" for a
+ * class Node constructs), so those branches leave the site to the
+ * reference's own fence instead.
+ *
+ * A token is recognized by its interned TEXT, not by its type alone: a
+ * program's own string casts to `any` as readily as an unsupported builtin
+ * export does, and `new ("hello" as any)()` is a Node TypeError to run, not
+ * a lowering fence. The checker test stays as a second condition, so a
+ * string the checker types as a string keeps its Node answer even when it
+ * spells a token. */
+export function isBuiltinIdentityToken(lowerer, node, value) {
+    if (value.kind !== "strLit")
+        return false;
+    if (!value.value.startsWith(BUILTIN_TOKEN_PREFIX))
+        return false;
+    if (!value.value.endsWith(BUILTIN_TOKEN_SUFFIX))
+        return false;
+    function stringLike(t) {
+        if ((t.flags & ts.TypeFlags.StringLike) !== 0)
+            return true;
+        return t.isUnionType() && ts.constituentTypes(t).every(stringLike);
+    }
+    return !stringLike(lowerer.typeOf(node));
+}
+/** The statements that evaluate `expr` for its effects alone. A value the
+ * IR cannot spell (a unit — JavaScript's null/undefined has no standalone
+ * runtime value, so a bare unit literal fails validation) contributes only
+ * the statements its sequence kept, and a plain unit literal none at all. */
+export function effectStmts(expr, loc) {
+    if (isSafeToDiscard(expr))
+        return [];
+    if (expr.kind === "seqExpr")
+        return [...expr.stmts, ...effectStmts(expr.result, loc)];
+    return [{ kind: "exprStmt", expr, loc }];
+}
+/** `thrown`, preceded by the evaluation of `values` in order — the shape of
+ * every object-coercion refusal whose operands still have to run before the
+ * throw (`(recordedKey() in nullishReceiver())`). */
+export function throwAfterEach(values, thrown, loc) {
+    const stmts = values.flatMap((value) => effectStmts(value, loc));
+    return stmts.length === 0
+        ? thrown
+        : { kind: "seqExpr", stmts, result: thrown, type: thrown.type, loc };
+}
+/** Expression-position `delete` (`const ok = delete x.y`). Every receiver but
+ * a primitive keeps the statement-position-only fence. */
+export function lowerDeleteExpression(lowerer, expr) {
+    let target = expr.expression;
+    while (ts.isParenthesizedExpression(target))
+        target = target.expression;
+    if (ts.isPropertyAccessExpression(target) || ts.isElementAccessExpression(target)) {
+        const obj = lowerer.lowerExpr(target.expression);
+        if (isPrimitiveValueType(obj.type) &&
+            !isBuiltinIdentityToken(lowerer, target.expression, obj)) {
+            return lowerPrimitiveBaseDelete(lowerer, expr, target, obj, BOOL);
+        }
+    }
+    lowerer.unsupported("SC1090", expr, "delete expressions");
+}
+/** `delete` on a primitive base, whose ToObject step gives the answer. The
+ * base evaluates first, then the key:
+ *
+ * - a nullish base throws Node's ToObject TypeError before the key's
+ *   ToPropertyKey, so the key runs without converting (and, through `?.`,
+ *   the chain short-circuits instead: the answer is `true` and the key
+ *   never runs);
+ * - any other primitive deletes from the ToObject wrapper. A String
+ *   wrapper carries its indexes and `length` as non-configurable own
+ *   properties, so deleting one answers `false` in sloppy code and throws
+ *   the TypeError in strict code, while every other primitive's wrapper
+ *   owns nothing. The runtime does the ToPropertyKey, which preserves a
+ *   Symbol key.
+ *
+ * `resultType` is the replaced expression's own type (never materialized). */
+export function lowerPrimitiveBaseDelete(lowerer, expr, target, obj, resultType) {
+    const loc = locOf(expr);
+    const unit = isUnitType(obj.type);
+    if (unit && target.questionDotToken) {
+        // `base?.[key]` on a nullish base: the chain is undefined, the delete
+        // answers true, and the key does not evaluate.
+        return throwAfterEach([obj], { kind: "boolLit", value: true, type: BOOL, loc }, loc);
+    }
+    const key = ts.isPropertyAccessExpression(target)
+        ? strLit(target.name.text, loc)
+        : lowerer.lowerExpr(target.argumentExpression);
+    if (unit)
+        return throwAfterEach([obj, key], deleteToObjectTypeError(resultType, loc), loc);
+    return {
+        kind: "libCall",
+        fn: "dyn.primitiveDelete",
+        args: [
+            lowerer.coerceToExpected(obj, DYN),
+            lowerer.coerceToExpected(key, DYN),
+            { kind: "boolLit", value: isStrictCode(expr), type: BOOL, loc },
+        ],
+        type: BOOL,
+        loc,
+    };
+}
+//# sourceMappingURL=primitive-throws.js.map

package/dist/frontend/lowering/primitive-throws.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive-throws.js","sourceRoot":"","sources":["../../../src/frontend/lowering/primitive-throws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;4BAS4B;AAC5B,OAAO,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACxC,OAAO,EACL,IAAI,EACJ,GAAG,EACH,MAAM,EACN,UAAU,GAKX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEtC,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD;;;gBAGgB;AAChB,MAAM,UAAU,oBAAoB,CAAC,CAAS;IAC5C,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,OAAO,CAAC;QACb,KAAK,YAAY,CAAC;QAClB,KAAK,MAAM,CAAC;QACZ,KAAK,MAAM,CAAC;QACZ,KAAK,KAAK,CAAC;QACX,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ;YACX,OAAO,IAAI,CAAC;QACd;YACE,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC;AAED;;;yCAGyC;AACzC,MAAM,UAAU,aAAa,CAAC,OAAgB,EAAE,KAAa,EAAE,GAAW;IACxE,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3B,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;IACzE,CAAC;IACD,OAAO;QACL,IAAI,EAAE,SAAS;QACf,EAAE,EAAE,uBAAuB;QAC3B,IAAI,EAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC5C,IAAI,EAAE,MAAM;QACZ,GAAG;KACJ,CAAC;AACJ,CAAC;AAED;wEACwE;AACxE,MAAM,UAAU,cAAc,CAAC,OAAe,EAAE,IAAY,EAAE,GAAW;IACvE,OAAO;QACL,IAAI,EAAE,SAAS;QACf,EAAE,EAAE,iBAAiB;QACrB,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC;QAChD,IAAI;QACJ,GAAG;KACJ,CAAC;AACJ,CAAC;AAED;;iEAEiE;AACjE,MAAM,UAAU,mBAAmB,CACjC,OAAgB,EAChB,GAAW,EACX,IAAY,EACZ,IAAY,EACZ,GAAW;IAEX,OAAO,cAAc,CACnB;QACE,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,MAAM,CAAC,2CAA2C,GAAG,OAAO,EAAE,GAAG,CAAC;QACxE,KAAK,EAAE,aAAa,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC;QACxC,IAAI,EAAE,MAAM;QACZ,GAAG;KACJ,EACD,IAAI,EACJ,GAAG,CACJ,CAAC;AACJ,CAAC;AAED;6EAC6E;AAC7E,MAAM,UAAU,uBAAuB,CAAC,IAAY,EAAE,GAAW;IAC/D,OAAO,cAAc,CAAC,MAAM,CAAC,4CAA4C,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;AAC9F,CAAC;AAED;;;;;;;;kDAQkD;AAClD,MAAM,UAAU,cAAc,CAAC,OAAgB,EAAE,IAAmB;IAClE,IAAI,IAAI,GAAG,IAAI,CAAC;IAChB,OAAO,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC;QAAE,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC;IAClE,IAAI,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW;QAAE,OAAO,MAAM,CAAC;IAC3D,IAAI,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC;QAAE,OAAO,WAAW,CAAC;IAClD,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW;QAAE,OAAO,IAAI,CAAC;IACrE,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC;IACzC,OAAO,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC;AAC7D,CAAC;AAED;;;;;iEAKiE;AACjE,MAAM,UAAU,mBAAmB,CAAC,OAAgB,EAAE,IAAmB;IACvE,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACvC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC;QAAE,OAAO,KAAK,CAAC;IACpE,uEAAuE;IACvE,OAAO,CACL,CAAC,KAAK;QACJ,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI;YAChB,EAAE,CAAC,SAAS,CAAC,SAAS;YACtB,EAAE,CAAC,SAAS,CAAC,IAAI;YACjB,EAAE,CAAC,SAAS,CAAC,WAAW;YACxB,EAAE,CAAC,SAAS,CAAC,UAAU;YACvB,EAAE,CAAC,SAAS,CAAC,UAAU;YACvB,EAAE,CAAC,SAAS,CAAC,UAAU;YACvB,EAAE,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QAC/B,CAAC,CACF,CAAC;AACJ,CAAC;AAED;;oCAEoC;AACpC,MAAM,UAAU,oBAAoB,CAClC,IAA0B,EAC1B,IAAY,EACZ,IAAY,EACZ,GAAW;IAEX,OAAO,cAAc,CACnB,MAAM,CAAC,6BAA6B,IAAI,cAAc,IAAI,IAAI,EAAE,GAAG,CAAC,EACpE,IAAI,EACJ,GAAG,CACJ,CAAC;AACJ,CAAC;AAED;;6EAE6E;AAC7E,MAAM,oBAAoB,GAAG,WAAW,CAAC;AACzC,MAAM,oBAAoB,GAAG,GAAG,CAAC;AAEjC;;;;;;;;;;;;;;;;qBAgBqB;AACrB,MAAM,UAAU,sBAAsB,CACpC,OAAgB,EAChB,IAAmB,EACnB,KAAa;IAEb,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC1C,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,oBAAoB,CAAC;QAAE,OAAO,KAAK,CAAC;IAChE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,oBAAoB,CAAC;QAAE,OAAO,KAAK,CAAC;IAC9D,SAAS,UAAU,CAAC,CAAU;QAC5B,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAC3D,OAAO,CAAC,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACrE,CAAC;IACD,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC3C,CAAC;AAED;;;6EAG6E;AAC7E,MAAM,UAAU,WAAW,CAAC,IAAY,EAAE,GAAW;IACnD,IAAI,eAAe,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IACrC,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IACtF,OAAO,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;AAC3C,CAAC;AAED;;qDAEqD;AACrD,MAAM,UAAU,cAAc,CAAC,MAAyB,EAAE,MAAc,EAAE,GAAW;IACnF,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;IACjE,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;QACvB,CAAC,CAAC,MAAM;QACR,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC;AACzE,CAAC;AAED;0DAC0D;AAC1D,MAAM,UAAU,qBAAqB,CAAC,OAAgB,EAAE,IAAyB;IAC/E,IAAI,MAAM,GAAkB,IAAI,CAAC,UAAU,CAAC;IAC5C,OAAO,EAAE,CAAC,yBAAyB,CAAC,MAAM,CAAC;QAAE,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC;IACxE,IAAI,EAAE,CAAC,0BAA0B,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,yBAAyB,CAAC,MAAM,CAAC,EAAE,CAAC;QAClF,MAAM,GAAG,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QACjD,IACE,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC;YAC9B,CAAC,sBAAsB,CAAC,OAAO,EAAE,MAAM,CAAC,UAAU,EAAE,GAAG,CAAC,EACxD,CAAC;YACD,OAAO,wBAAwB,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IACD,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,EAAE,oBAAoB,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;;;;;;;;;8EAc8E;AAC9E,MAAM,UAAU,wBAAwB,CACtC,OAAgB,EAChB,IAAyB,EACzB,MAAgE,EAChE,GAAW,EACX,UAAkB;IAElB,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;IACxB,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,IAAI,IAAI,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACpC,sEAAsE;QACtE,+CAA+C;QAC/C,OAAO,cAAc,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,GAAG,CAAC,CAAC;IACvF,CAAC;IACD,MAAM,GAAG,GAAG,EAAE,CAAC,0BAA0B,CAAC,MAAM,CAAC;QAC/C,CAAC,CAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAY;QAC3C,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC;IACjD,IAAI,IAAI;QAAE,OAAO,cAAc,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,uBAAuB,CAAC,UAAU,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;IAC3F,OAAO;QACL,IAAI,EAAE,SAAS;QACf,EAAE,EAAE,qBAAqB;QACzB,IAAI,EAAE;YACJ,OAAO,CAAC,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC;YAClC,OAAO,CAAC,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC;YAClC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE;SAChE;QACD,IAAI,EAAE,IAAI;QACV,GAAG;KACJ,CAAC;AACJ,CAAC"}

package/dist/frontend/lowering/primitive-wrappers.d.ts

@@ -0,0 +1,34 @@
+import * as ts from "../ts7/adapter.js";
+import { type IrExpr, type IrFunction, type SrcLoc } from "../../ir/ir.js";
+import type { Lowerer } from "./lowerer.js";
+export type WrapperKind = "String" | "Number" | "Boolean";
+/** The runtime's kind numbers (scr_js_wrapper.c SCR_JS_WRAPPER_*). */
+export declare const WRAPPER_KIND_NUMBER: Record<WrapperKind, number>;
+/** Whether any compiled source creates a primitive wrapper: a `new` of the
+ * stdlib String, Number or Boolean constructor (with or without an
+ * argument: `new String()` is a wrapper over "", `new Number()` over 0 and
+ * `new Boolean()` over false), or a call of the stdlib Object with an
+ * argument. `new Object()` without one is a fresh plain object, so it is
+ * not a wrapper. Until a program has one, no value is a wrapper, so the
+ * boxed interface types keep their primitive mapping and every fold that
+ * relies on it stays. */
+export declare function programCreatesWrappers(lowerer: Lowerer): boolean;
+/** `new String(x)` / `new Number(x)` / `new Boolean(x)` in a JavaScript
+ * source: the wrapper over ToString/ToNumber/ToBoolean of the argument
+ * (the runtime converts, with the object hooks), or over "", 0, false
+ * without one. Null outside JavaScript sources and for other callees. */
+export declare function lowerWrapperNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr | null;
+/** The String, Number and Boolean constructor values, for the prototypes'
+ * `constructor` property (the interned closures `x === String` compares). */
+export declare function wrapperConstructors(lowerer: Lowerer, loc: SrcLoc): IrExpr[];
+/** In a program that creates wrappers, route the consumers that read
+ * internal slots: Object.prototype.toString's tag and the util.types
+ * brands answer from the slot (wrapper.objectTag, wrapper.typeIs), and the
+ * graph-walking consumers above guard their dynamic arguments. Programs
+ * without a wrapper site keep every node unchanged. */
+export declare function routeWrapperConsumers(lowerer: Lowerer, functions: IrFunction[]): void;
+/** `Object(x)` / `new Object(x)` over a checked-dynamic `x` in a program
+ * that creates wrappers: ToObject (wrapper.toObject), a wrapper for a
+ * primitive, the value itself for an object, a fresh object for null and
+ * undefined. */
+export declare function lowerWrapperToObject(lowerer: Lowerer, value: IrExpr, loc: SrcLoc): IrExpr;