@scriptc/compiler 0.0.10 → 0.0.11

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;

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

@@ -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 —
@@ -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) {
@@ -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;