@scriptc/compiler 0.0.10 → 0.0.12

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

@@ -344,6 +344,10 @@ export declare function lowerBytesNew(L: Lowerer, expr: ts.NewExpression, symbol
    * else the lib declares (fill, indexOf, reverse, ...) falls through to
    * the SC2020 member fence. Null when this isn't a bytes method call. */
 export declare function lowerBytesMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+/** A literal encoding's canonical name, or undefined for a spelling Node
+ * does not know — the ladder callers (stream options) turn unknown
+ * literals into Node's runtime ERR_UNKNOWN_ENCODING throw. */
+export declare function knownBufEncoding(name: string): string | undefined;
 /** The literal encoding argument of a Buffer surface, normalized — or a
  * fence when it isn't a literal alias Node knows. */
 export declare function bufEncoding(L: Lowerer, what: string, encNode: ts.Expression): string;
@@ -362,7 +366,7 @@ export declare function lowerBufferStaticCall(L: Lowerer, call: ts.CallExpressio
    * result order is Node-exact; hybrids inherit the documented
    * declared-then-overflow divergence. Values surface as the checker's
    * result element type: identity, an arm-into-union wrap, or (dyn
-   * results) the DOM conversion — recordKeyGet's own surfacing rules for
+   * results) the dyn conversion — recordKeyGet's own surfacing rules for
    * the overflow, mirrored statically for declared fields. */
 export declare function lowerObjectIterOverIndexShape(L: Lowerer, call: ts.CallExpression, member: "keys" | "values" | "entries", argIr: IrType & {
     kind: "record";
@@ -481,9 +485,9 @@ export declare function lowerEnvToPairsHelper(L: Lowerer, shapeId: string, loc:
 /** The validated-STRING extraction of a dyn method receiver — the receiver
  * expression the string/regex method lowerings consume. */
 export declare function dynStringReceiver(L: Lowerer, recv: IrExpr, access: ts.PropertyAccessExpression): IrExpr;
-/** `d.filter(pred)` on a dyn receiver: the receiver must BE a DOM array
+/** `d.filter(pred)` on a dyn receiver: the receiver must BE a dyn array
  * (else the Node-shaped TypeError above); the predicate runs per element
- * over the DOM value, and each SURVIVOR is validated-extracted into the
+ * over the dyn value, and each SURVIVOR is validated-extracted into the
  * result's element type T — the type the checker already committed the
  * call to (the contextual `RouteMapping[]`/`string[]` slot). Extraction is
  * the checked-cast machinery: a survivor that doesn't fit T throws the
@@ -494,9 +498,9 @@ export declare function dynStringReceiver(L: Lowerer, recv: IrExpr, access: ts.P
 export declare function lowerDynArrayFilterCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr): IrExpr | null;
 /** `.flatMap(f)` on a dyn ('unknown'/`any[]`-narrowed) receiver where the
    * callback returns a STATIC array (`parsed.flatMap((v) => typeof v ===
-   * "string" ? parseTldList(v) : [])` — the tlds-file shape): the DOM
+   * "string" ? parseTldList(v) : [])` — the tlds-file shape): the checked-dynamic tree
    * array walks element-by-element, the callback sees each element as the
-   * DOM value `unknown` code sees, and its typed results concatenate —
+   * dyn value `unknown` code sees, and its typed results concatenate —
    * depth-1 flatten by construction, no validation needed on the results
    * (they are already typed; only the RECEIVER is dynamic). Non-array
    * receivers throw the Node-shaped TypeError. Callbacks returning

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

@@ -65,11 +65,11 @@ export function lowerArrayMethodCall(L, call, access) {
             const result = { kind: "jsOp", op: "callMethod", name, args: [receiver, ...args], type: JSVAL, loc };
             return islandPrimitiveExit(L, call, result);
         }
-        // An array-mapped CHECKER type whose VALUE lives in the DOM
-        // (`Object.keys(dynObj).sort()` — the key-walk answers a DOM array):
+        // An array-mapped CHECKER type whose VALUE lives in the checked-dynamic tree
+        // (`Object.keys(dynObj).sort()` — the key-walk answers a dyn array):
         // the record family's array sibling. Methods with a runtime
         // receiver-kind dispatch ride dynInvoke — the real method runs on
-        // the DOM array, JS-exact; the rest keep an honest fence instead of
+        // the dyn array, JS-exact; the rest keep an honest fence instead of
         // handing a static array intrinsic a dyn receiver (the validator
         // ICE). Consumers validate the dyn result where a static type is
         // required (dynCheck — the member-read discipline).
@@ -336,7 +336,7 @@ function hofCallbackArg(L, argNode, lead, arrT) {
     // A DYN-receiver HOF's callback (`parsed.flatMap((value) => ...)`):
     // the contextual signature types the unannotated param `any` (the
     // receiver is checker-`any[]`), while the VALUE each call receives is
-    // the DOM element `unknown` code sees — narrow the param declaration
+    // the dyn element `unknown` code sees — narrow the param declaration
     // to `unknown` so it lowers as the dyn it carries (typeof tests and
     // validated extractions ride as usual) instead of fencing on `any`.
     const overridden = [];
@@ -4004,9 +4004,26 @@ export function lowerRegexMethodCall(L, call, access, dynReceiver) {
     // [whole match, ...captures] or the null arm. The g-flag match returns
     // EVERY match (a different shape) and /y is stateful — both fence at
     // compile time on literal arguments (values reaching the runtime with
-    // those flags abort, the test() stance). `.index`/`.input`/`.groups`
-    // reads on the result fence per member (array-typed value).
-    if (receiverKind === "string" && name === "match") {
+    // those flags abort, the test() stance). `.index`/`.input` reads on
+    // the result fence per member (array-typed value); `.groups` reads
+    // desugar at their access sites when the regex is statically known
+    // (lowerMatchGroupsRead).
+    // `s.match(re)` also claims a NULLABLE string receiver (string + unit
+    // arms — `process.versions.openssl.match(...)`, the Dict<string>
+    // member the node suite's crypto helper reads): the checked
+    // extraction narrows to the string arm and a unit value throws the
+    // catchable TypeError at the read, where Node's own member read
+    // throws — tsc only admits the spelling in JS sources.
+    const nullableStringRecv = receiverKind === "union" &&
+        name === "match" &&
+        (() => {
+            const t = L.mapTypeOf(L.typeOf(access.expression));
+            if (t?.kind !== "union")
+                return false;
+            const arms = L.unions.get(t.unionId)?.arms ?? [];
+            return arms.some((a) => a.kind === "string") && arms.every((a) => a.kind === "string" || isUnitType(a));
+        })();
+    if ((receiverKind === "string" || nullableStringRecv) && name === "match") {
         const arg0 = call.arguments[0];
         if (!arg0 || L.mapTypeOf(L.typeOf(arg0))?.kind !== "regex")
             return null; // string-pattern match: the SC2020 fence
@@ -4021,7 +4038,7 @@ export function lowerRegexMethodCall(L, call, access, dynReceiver) {
                 L.unsupported("SC1120", call, "'.match()' with the 'g' or 'y' flag (an every-match array is a different shape — use replaceAll/split, or test() per position)");
             }
         }
-        const receiver = lowerReceiver();
+        const receiver = nullableStringRecv ? L.lowerExprExpecting(access.expression, STRING) : lowerReceiver();
         const re = L.lowerExpr(arg0);
         // RegExpMatchArray | null maps to the string[] | null union by
         // itself; intern it directly when the checker's spelling doesn't —
@@ -4116,7 +4133,7 @@ export function lowerStringMethodCall(L, call, access, dynReceiver) {
         return null;
     // A validated dyn receiver (`pkg.name.replace(...)` on a JSON.parse
     // value) arrives pre-extracted through `dynReceiver`; its checker type
-    // is `any`, so the type/symbol gates don't apply — the DOM value's
+    // is `any`, so the type/symbol gates don't apply — the dyn value's
     // methods can only BE the string intrinsics.
     if (dynReceiver === undefined) {
         const receiverIr = L.mapTypeOf(L.typeOf(access.expression));
@@ -4395,8 +4412,30 @@ export function lowerBytesMethodCall(L, call, access) {
         }
         const receiver = L.lowerExpr(access.expression);
         const args = call.arguments.map((a) => L.lowerExprExpecting(a, F64));
-        // subarray COPIES here (no views exist) — SEMANTICS.md documents it.
-        return { kind: "bytesIntrinsic", method: "slice", receiver, args, type: receiverIr, loc };
+        // subarray is a VIEW (TypedArray.prototype.subarray aliases), and
+        // Buffer's slice() is subarray's deprecated Node alias — resolved by
+        // where the member is declared, the toString discipline below. Only
+        // the plain typed arrays' slice() copies (JS-exact).
+        const declaredOnBuffer = name === "slice" &&
+            (() => {
+                const nameSym = L.checker.getSymbolAtLocation(access.name);
+                return nameSym !== undefined && L.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
+            })();
+        const method = name === "subarray" || declaredOnBuffer ? "subarray" : "slice";
+        return { kind: "bytesIntrinsic", method, receiver, args, type: receiverIr, loc };
+    }
+    if (name === "fill" && receiverIr.elem !== "u8") {
+        // TypedArray.prototype.fill on the non-u8 kinds: per-element value
+        // coercion, slice-clamped relative indices, never throws. u8
+        // receivers keep the Buffer fill family (string patterns, throwing
+        // offset validation) — lowerBufferInstanceMethod's surface.
+        if (nArgs < 1 || nArgs > 3) {
+            L.noLowering(`.fill with ${nArgs} arguments on typed arrays`, call);
+        }
+        const receiver = L.lowerExpr(access.expression);
+        const v = L.lowerExprExpecting(call.arguments[0], F64);
+        const idx = call.arguments.slice(1).map((a) => L.lowerExprExpecting(a, F64));
+        return { kind: "bytesIntrinsic", method: "fillElem", receiver, args: [v, ...idx], type: receiverIr, loc };
     }
     if (name === "set") {
         if (nArgs < 1 || nArgs > 2) {
@@ -4571,6 +4610,12 @@ const BUF_ENCODINGS = {
     ucs2: "utf16le",
     "ucs-2": "utf16le",
 };
+/** A literal encoding's canonical name, or undefined for a spelling Node
+ * does not know — the ladder callers (stream options) turn unknown
+ * literals into Node's runtime ERR_UNKNOWN_ENCODING throw. */
+export function knownBufEncoding(name) {
+    return own(BUF_ENCODINGS, name);
+}
 /** The literal encoding argument of a Buffer surface, normalized — or a
  * fence when it isn't a literal alias Node knows. */
 export function bufEncoding(L, what, encNode) {
@@ -4646,7 +4691,7 @@ function lowerBufferInstanceMethod(L, call, access, name, loc) {
     // literals) wrap in dynFrom, `undefined` literals ride the same wrap.
     // Fences (never returns) when the value cannot cross — an island jsval.
     const chkArg = (i) => {
-        // Object literals take the DOM literal path directly (method members
+        // Object literals take the dyn literal path directly (method members
         // box as dyn functions — the typed record fence never applies).
         if (ts.isObjectLiteralExpression(args[i])) {
             return lowerDynObjectLiteral(L, args[i]);
@@ -4853,6 +4898,22 @@ export function lowerBufferStaticCall(L, call, access) {
     const loc = locOf(call);
     const args = call.arguments;
     if (member === "from") {
+        // Buffer.from(x.buffer[, byteOffset[, length]]): a u8 VIEW sharing
+        // x's storage (Node shares the ArrayBuffer; length is in BYTES).
+        // The first argument must be the SYNTACTIC `.buffer` of a typed
+        // array — the DataView peel — and the construction rides the same
+        // dataViewNew intrinsic (offset/length validation throws Node's
+        // DataView-shaped RangeErrors; valid indices behave exactly).
+        if (args.length >= 1 && args.length <= 3 && !args.some(ts.isSpreadElement) &&
+            ts.isPropertyAccessExpression(args[0]) && args[0].name.text === "buffer") {
+            const srcNode = args[0].expression;
+            const srcIr = L.mapTypeOf(L.typeOf(srcNode));
+            if (srcIr?.kind === "bytes") {
+                const receiver = L.lowerExpr(srcNode);
+                const idxArgs = args.slice(1).map((a) => L.lowerExprExpecting(a, F64));
+                return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
+            }
+        }
         if (args.length >= 1 && args.length <= 2 && !ts.isSpreadElement(args[0])) {
             const argNode = args[0];
             if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
@@ -4882,7 +4943,8 @@ export function lowerBufferStaticCall(L, call, access) {
             }
         }
         L.noLowering("Buffer.from with this argument shape", call, "supported: Buffer.from(string, encoding?) with a literal encoding, Buffer.from(u8Array) — a copy — " +
-            "or Buffer.from(number[]); ArrayBuffers do not exist here (narrow unions first)");
+            "Buffer.from(number[]), or Buffer.from(x.buffer, byteOffset?, length?) — a view sharing x's " +
+            "storage (no free-standing ArrayBuffer value exists; narrow unions first)");
     }
     if (member === "alloc" || member === "allocUnsafe") {
         const maxArgs = member === "alloc" ? 3 : 1;
@@ -5025,7 +5087,7 @@ export function lowerBufferStaticCall(L, call, access) {
    * result order is Node-exact; hybrids inherit the documented
    * declared-then-overflow divergence. Values surface as the checker's
    * result element type: identity, an arm-into-union wrap, or (dyn
-   * results) the DOM conversion — recordKeyGet's own surfacing rules for
+   * results) the dyn conversion — recordKeyGet's own surfacing rules for
    * the overflow, mirrored statically for declared fields. */
 export function lowerObjectIterOverIndexShape(L, call, member, argIr, shape) {
     const resultT = L.irTypeOf(call);
@@ -5538,7 +5600,7 @@ export function lowerRecordOvfCaptureHelper(L, fromId, toId, loc) {
     // target also declares. Non-dyn slots store THROUGH on a collision, so
     // such writes need every declared field to BE the slot type (the
     // validator's recordKeySet rule); dyn slots validate per field
-    // (dynCheck), so each field must be DOM-convertible. Writes to
+    // (dynCheck), so each field must be dyn-convertible. Writes to
     // literal names the target does NOT declare are overflowOnly and
     // exempt — which is what lets a direct-initialized required field
     // (`id: number` beside a `number | undefined` slot) coexist with a
@@ -6284,7 +6346,7 @@ export function lowerEnvToPairsHelper(L, shapeId, loc) {
 }
 /* ── dyn METHOD receivers ──────────────────────────────────────────────────
  * Method calls on `unknown`/JSON.parse-derived receivers (`pkg.name
- * .replace(...)`, `ws.packages.filter(...)`): validate the receiver's DOM
+ * .replace(...)`, `ws.packages.filter(...)`): validate the receiver's dyn
  * kind, extract, then ride the STATIC method machinery — the dyn boundary's
  * trust-but-VERIFY stance extended to receivers. A receiver of the wrong
  * kind throws the catchable Node-shaped TypeError V8 would ("x.replace is
@@ -6387,9 +6449,9 @@ export function dynStringReceiver(L, recv, access) {
         loc,
     };
 }
-/** `d.filter(pred)` on a dyn receiver: the receiver must BE a DOM array
+/** `d.filter(pred)` on a dyn receiver: the receiver must BE a dyn array
  * (else the Node-shaped TypeError above); the predicate runs per element
- * over the DOM value, and each SURVIVOR is validated-extracted into the
+ * over the dyn value, and each SURVIVOR is validated-extracted into the
  * result's element type T — the type the checker already committed the
  * call to (the contextual `RouteMapping[]`/`string[]` slot). Extraction is
  * the checked-cast machinery: a survivor that doesn't fit T throws the
@@ -6427,8 +6489,8 @@ export function lowerDynArrayFilterCall(L, call, access, recv) {
     if (!elemT || !L.jsonSafe(elemT)) {
         // No JSON-representable destination (`const failed = checks.filter(
         // fn)` in untyped JS — test/common's runCallChecks): the result
-        // STAYS in the DOM — the runtime prototype dispatch (scr_dyn_invoke)
-        // runs the real filter over the DOM array and the survivors keep
+        // STAYS in the checked-dynamic tree — the runtime prototype dispatch (scr_dyn_invoke)
+        // runs the real filter over the dyn array and the survivors keep
         // their dyn selves, no extraction needed. The typed-destination path
         // above stays preferred: it hands back a real T[].
         return null;
@@ -6452,9 +6514,9 @@ export function lowerDynArrayFilterCall(L, call, access, recv) {
 }
 /** `.flatMap(f)` on a dyn ('unknown'/`any[]`-narrowed) receiver where the
    * callback returns a STATIC array (`parsed.flatMap((v) => typeof v ===
-   * "string" ? parseTldList(v) : [])` — the tlds-file shape): the DOM
+   * "string" ? parseTldList(v) : [])` — the tlds-file shape): the checked-dynamic tree
    * array walks element-by-element, the callback sees each element as the
-   * DOM value `unknown` code sees, and its typed results concatenate —
+   * dyn value `unknown` code sees, and its typed results concatenate —
    * depth-1 flatten by construction, no validation needed on the results
    * (they are already typed; only the RECEIVER is dynamic). Non-array
    * receivers throw the Node-shaped TypeError. Callbacks returning
@@ -6470,10 +6532,10 @@ export function lowerDynArrayFlatMapCall(L, call, access, recv) {
     if (ret.kind !== "array") {
         // A DYNAMIC-returning callback (`plugins.flatMap((plugin) =>
         // plugin.languages ?? [])` — the getSupportInfo shape, where the
-        // callback's members ride the DOM): the call dispatches on the
+        // callback's members ride the checked-dynamic tree): the call dispatches on the
         // RECEIVER's runtime kind (dynInvoke) with the callback boxed —
         // a wrapped ISLAND receiver runs the ENGINE's own JS-exact
-        // Array.prototype.flatMap (the routed-ops lane), a native DOM
+        // Array.prototype.flatMap (the routed-ops lane), a native dyn
         // array runs the runtime's flatMap, and non-arrays throw Node's
         // TypeError. The result stays dyn, checked per use.
         if (ret.kind === "dyn" || ret.kind === "jsval") {
@@ -6643,10 +6705,10 @@ function dynFilterHelper(L, elemT, arity, loc) {
 }
 /** out = []; n = d.length; for (i..n) { v = d[i]; if (f(v, i, d)) out.push(
  * check<T>(v)); } return out; — with the receiver-kind gate up front. The
- * length reads ONCE (the DOM is immutable under the static surface), the
+ * length reads ONCE (the checked-dynamic tree is immutable under the static surface), the
  * element reads through the canonical-index keyed read, the callback gets
  * whatever prefix of (element, index, receiver) it declares — the element
- * and receiver as DOM values, exactly what `unknown` code sees. */
+ * and receiver as dyn values, exactly what `unknown` code sees. */
 function buildDynFilterFn(name, elemT, arity, loc) {
     const outT = arrayOf(elemT);
     const fnT = funcOf([DYN, F64, DYN].slice(0, arity), BOOL);