@scriptc/compiler 0.4.0 → 0.4.1

package/dist/frontend/lowering/containers/bytes.d.ts

@@ -32,4 +32,13 @@ 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(lowerer: Lowerer, what: string, encNode: ts.Expression): string;
+/** The deprecated `new Buffer(arg[, encoding])` in a dependency's
+ * JavaScript, through the global or an alias of it (buffer-crc32 and yazl
+ * keep it as the fallback for runtimes without Buffer.alloc/Buffer.from).
+ * Node never emits DEP0005 for calls from node_modules, so the construction
+ * is exactly Node's: a number allocates zero-filled bytes (and throws
+ * ERR_INVALID_ARG_TYPE beside a string second argument), anything else
+ * converts as Buffer.from does. Null elsewhere: other callers owe the
+ * deprecation warning. */
+export declare function lowerNodeModulesBufferConstruct(lowerer: Lowerer, expr: ts.NewExpression): IrExpr | null;
 export declare function lowerBufferStaticCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;

package/dist/frontend/lowering/containers/bytes.js

@@ -1,8 +1,9 @@
-import { dynUndefinedExpr, varRef } from "../../../ir/build.js";
+import { boolLit, dynUndefinedExpr, numLit, varRef } from "../../../ir/build.js";
 import { BUF_NUM_METHODS } from "./buffer-numeric-methods.js";
 import * as ts from "../../ts7/adapter.js";
 import { BIGINT_T, BOOL, BYTES_ELEMENT_NAME, BYTES_U8, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, funcOf, isUnitType, typeEquals, } from "../../../ir/ir.js";
 import { isJsSourceFile, locOf } from "../../program.js";
+import { stdlibGlobalNameOf } from "../surfaces.js";
 import { newFnCtx, own } from "../lowerer.js";
 import { buildBytesSortFn, closureKeyOrder } from "../lower-array-sort.js";
 import { isSafeToDiscard } from "../expressions/evaluation-safety.js";
@@ -11,6 +12,9 @@ import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedA
 import { lowerCheckedArrayFrom } from "./array-construction.js";
 import { lowerToNumberArgument } from "../lower-exprs.js";
 import { lowerBytesIteratorValue } from "../iterator-adapters.js";
+import { lowerArrayCallback } from "./callback-arguments.js";
+import { findPredicateOk, predicateToBoolean } from "./array-callbacks.js";
+import { typeKey } from "../../type-mapper.js";
 /** TypedArray.prototype.sort and toSorted. The receiver and comparator
  * expressions are evaluated before entering the helper (buildBytesSortFn).
  * The default order is numeric, so the comparator-less form sorts by value
@@ -90,7 +94,7 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
     }
     const arity = fnArg.type.params.length;
     const keyed = closureKeyOrder(lowerer.liftedFns, fnArg);
-    const order = keyed !== null && keyed.read === null ? keyed.order : null;
+    const order = keyed?.length === 1 && keyed[0].read === null ? keyed[0].order : null;
     const helper = helperFor(`${arity}${order === null ? "" : `:keyed${order}`}`, arity, true, order);
     return {
         kind: "call",
@@ -100,6 +104,317 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
         loc,
     };
 }
+const BYTES_CALLBACK_METHODS = new Set([
+    "forEach",
+    "map",
+    "filter",
+    "some",
+    "every",
+    "find",
+    "findIndex",
+    "findLast",
+    "findLastIndex",
+    "reduce",
+    "reduceRight",
+]);
+/** The typed-array callback methods (forEach, map, filter, some, every,
+ * find, findIndex, findLast, findLastIndex, reduce, reduceRight). The
+ * receiver, the callback and reduce's initial value evaluate in order
+ * before the helper runs. The helper reads the length once (typed arrays
+ * have no holes) and each element when it visits it, so the callback's
+ * writes show in later elements. The callback receives the element, its
+ * index and the typed array (reduce's receive the accumulator first). map
+ * and filter return a new typed array of the receiver's kind; map stores
+ * each result with the element conversion of that kind. A thisArg keeps
+ * the fence, as for arrays. */
+function lowerBytesCallbackCall(lowerer, call, access, method, bytesT) {
+    const loc = locOf(call);
+    const nArgs = call.arguments.nodes.length;
+    const reduce = method === "reduce" || method === "reduceRight";
+    if (nArgs < 1 || nArgs > (reduce ? 2 : 1) || call.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`.${method} with ${nArgs} arguments on ${BYTES_ELEMENT_NAME[bytesT.elem]}`, call, reduce ? undefined : "the thisArg parameter has no lowering — use an arrow function");
+    }
+    const argNode = call.arguments.nodes[0];
+    const hasInit = reduce && nArgs === 2;
+    const accT = reduce ? (hasInit ? lowerer.irTypeOf(call) : F64) : null;
+    if (accT !== null && (accT.kind === "void" || accT.kind === "func"))
+        lowerer.badType(call, lowerer.typeOf(call));
+    const receiver = lowerer.lowerExprExpecting(access.expression, bytesT);
+    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, accT !== null ? [accT, F64] : [F64], bytesT, false, accT ?? undefined);
+    const fnRet = fnArg.type.ret;
+    const predicate = method === "filter" ||
+        method === "some" ||
+        method === "every" ||
+        method === "find" ||
+        method === "findIndex" ||
+        method === "findLast" ||
+        method === "findLastIndex";
+    if (predicate && !findPredicateOk(lowerer, fnRet))
+        lowerer.badType(argNode, lowerer.typeOf(argNode));
+    if (method === "map" && !lowerer.coercibleValue(F64, fnRet))
+        lowerer.badType(argNode, lowerer.typeOf(argNode));
+    const resultT = accT ??
+        (method === "forEach"
+            ? VOID
+            : method === "map" || method === "filter"
+                ? bytesT
+                : method === "some" || method === "every"
+                    ? BOOL
+                    : method === "findIndex" || method === "findLastIndex"
+                        ? F64
+                        : lowerer.irTypeOf(call));
+    const helper = bytesCallbackHelper(lowerer, method, bytesT, resultT, fnRet, arity, hasInit, loc);
+    const args = [receiver, fnArg];
+    if (hasInit)
+        args.push(lowerer.lowerExprExpecting(call.arguments.nodes[1], resultT));
+    return { kind: "call", callee: helper, args, type: resultT, loc };
+}
+/** The interned helper of one typed-array callback method shape. */
+function bytesCallbackHelper(lowerer, method, bytesT, resultT, fnRet, arity, hasInit, loc) {
+    const key = `bytes.${method}:${bytesT.elem}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : ""}`;
+    const existing = lowerer.arrHofHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%bytes.${method}.${lowerer.arrHofHelpers.size}`;
+    lowerer.arrHofHelpers.set(key, name);
+    const reduce = method === "reduce" || method === "reduceRight";
+    const backward = method === "reduceRight" || method === "findLast" || method === "findLastIndex";
+    const fnT = funcOf((reduce ? [resultT, F64, F64, bytesT] : [F64, F64, bytesT]).slice(0, arity), fnRet);
+    const keptT = arrayOf(F64);
+    const a = () => varRef("a.0", bytesT, loc);
+    const i = () => varRef("i.0", F64, loc);
+    const n = () => varRef("n.0", F64, loc);
+    const acc = () => varRef("acc.0", resultT, loc);
+    const element = () => varRef("v.0", F64, loc);
+    const at = (index) => ({
+        kind: "bytesIntrinsic",
+        method: "get",
+        receiver: a(),
+        args: [index],
+        type: F64,
+        loc,
+    });
+    const callback = () => ({
+        kind: "callValue",
+        callee: varRef("f.0", fnT, loc),
+        args: (reduce ? [acc(), element(), i(), a()] : [element(), i(), a()]).slice(0, arity),
+        type: fnRet,
+        loc,
+    });
+    const inRange = () => backward
+        ? { kind: "bin", op: ">=", left: i(), right: numLit(0, loc), type: BOOL, loc }
+        : { kind: "bin", op: "<", left: i(), right: n(), type: BOOL, loc };
+    const advance = () => ({
+        kind: "assign",
+        localId: "i.0",
+        value: {
+            kind: "bin",
+            op: backward ? "-" : "+",
+            left: i(),
+            right: numLit(1, loc),
+            type: F64,
+            loc,
+        },
+        loc,
+    });
+    const ret = (value) => ({ kind: "return", value, loc });
+    // map and filter of a Buffer return a Buffer (Node's species).
+    const copyBrand = (out) => ({
+        kind: "exprStmt",
+        expr: { kind: "libCall", fn: "bytes.copyBrand", args: [out, a()], type: VOID, loc },
+        loc,
+    });
+    const locals = [
+        { id: "a.0", name: "a", type: bytesT, mutable: true },
+        { id: "f.0", name: "f", type: fnT, mutable: true },
+        ...(hasInit ? [{ id: "z.0", name: "z", type: resultT, mutable: true }] : []),
+        ...(reduce || method === "map" || method === "filter"
+            ? [{ id: "acc.0", name: "acc", type: resultT, mutable: true }]
+            : []),
+        ...(method === "filter"
+            ? [{ id: "kept.0", name: "kept", type: keptT, mutable: true }]
+            : []),
+        { id: "n.0", name: "n", type: F64, mutable: false },
+        { id: "i.0", name: "i", type: F64, mutable: true },
+        { id: "v.0", name: "v", type: F64, mutable: true },
+    ];
+    const params = [
+        { localId: "a.0", name: "a", type: bytesT },
+        { localId: "f.0", name: "f", type: fnT },
+        ...(hasInit ? [{ localId: "z.0", name: "z", type: resultT }] : []),
+    ];
+    const visit = [{ kind: "assign", localId: "v.0", value: at(i()), loc }];
+    const prologue = [];
+    let epilogue;
+    switch (method) {
+        case "forEach":
+            visit.push({ kind: "exprStmt", expr: callback(), loc });
+            epilogue = [ret(null)];
+            break;
+        case "map":
+            prologue.push({
+                kind: "varDecl",
+                localId: "acc.0",
+                init: { kind: "bytesNew", source: n(), type: bytesT, loc },
+                loc,
+            });
+            visit.push({
+                kind: "bytesSet",
+                arr: acc(),
+                index: i(),
+                value: lowerer.coerceToExpected(callback(), F64),
+                loc,
+            });
+            if (bytesT.elem === "u8")
+                prologue.push(copyBrand(acc()));
+            epilogue = [ret(acc())];
+            break;
+        case "filter":
+            prologue.push({
+                kind: "varDecl",
+                localId: "kept.0",
+                init: { kind: "arrayLit", elems: [], type: keptT, loc },
+                loc,
+            });
+            visit.push({
+                kind: "if",
+                cond: predicateToBoolean(callback()),
+                then: [
+                    {
+                        kind: "exprStmt",
+                        expr: {
+                            kind: "arrIntrinsic",
+                            method: "push",
+                            receiver: varRef("kept.0", keptT, loc),
+                            args: [element()],
+                            type: F64,
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                else_: null,
+                loc,
+            });
+            epilogue = [
+                {
+                    kind: "varDecl",
+                    localId: "acc.0",
+                    init: { kind: "bytesNew", source: varRef("kept.0", keptT, loc), type: bytesT, loc },
+                    loc,
+                },
+                ...(bytesT.elem === "u8" ? [copyBrand(acc())] : []),
+                ret(acc()),
+            ];
+            break;
+        case "some":
+        case "every": {
+            const found = method === "some";
+            const test = predicateToBoolean(callback());
+            visit.push({
+                kind: "if",
+                cond: found ? test : { kind: "unary", op: "!", operand: test, type: BOOL, loc },
+                then: [ret(boolLit(found, loc))],
+                else_: null,
+                loc,
+            });
+            epilogue = [ret(boolLit(!found, loc))];
+            break;
+        }
+        case "find":
+        case "findLast":
+            visit.push({
+                kind: "if",
+                cond: predicateToBoolean(callback()),
+                then: [ret(lowerer.coerceToExpected(element(), resultT))],
+                else_: null,
+                loc,
+            });
+            epilogue = [
+                ret(lowerer.coerceToExpected({ kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc }, resultT)),
+            ];
+            break;
+        case "findIndex":
+        case "findLastIndex":
+            visit.push({
+                kind: "if",
+                cond: predicateToBoolean(callback()),
+                then: [ret(i())],
+                else_: null,
+                loc,
+            });
+            epilogue = [ret(numLit(-1, loc))];
+            break;
+        case "reduce":
+        case "reduceRight":
+            if (hasInit) {
+                prologue.push({
+                    kind: "varDecl",
+                    localId: "acc.0",
+                    init: varRef("z.0", resultT, loc),
+                    loc,
+                });
+            }
+            else {
+                prologue.push({
+                    kind: "if",
+                    cond: { kind: "unary", op: "!", operand: inRange(), type: BOOL, loc },
+                    then: [
+                        {
+                            kind: "throw",
+                            value: {
+                                kind: "libCall",
+                                fn: "error.new",
+                                args: [
+                                    {
+                                        kind: "strLit",
+                                        value: "Reduce of empty array with no initial value",
+                                        type: STRING,
+                                        loc,
+                                    },
+                                ],
+                                type: { kind: "object", className: "%TypeError" },
+                                loc,
+                            },
+                            loc,
+                        },
+                    ],
+                    else_: null,
+                    loc,
+                }, { kind: "varDecl", localId: "acc.0", init: at(i()), loc }, advance());
+            }
+            visit.push({
+                kind: "assign",
+                localId: "acc.0",
+                value: lowerer.coerceToExpected(callback(), resultT),
+                loc,
+            });
+            epilogue = [ret(acc())];
+            break;
+    }
+    const body = [
+        {
+            kind: "varDecl",
+            localId: "n.0",
+            init: { kind: "bytesIntrinsic", method: "length", receiver: a(), args: [], type: F64, loc },
+            loc,
+        },
+        {
+            kind: "varDecl",
+            localId: "i.0",
+            init: backward
+                ? { kind: "bin", op: "-", left: n(), right: numLit(1, loc), type: F64, loc }
+                : numLit(0, loc),
+            loc,
+        },
+        { kind: "varDecl", localId: "v.0", init: numLit(0, loc), loc },
+        ...prologue,
+        { kind: "for", init: null, cond: inRange(), update: advance(), body: visit, loc },
+        ...epilogue,
+    ];
+    lowerer.liftedFns.push({ name, params, returnType: resultT, locals, body, loc });
+    return name;
+}
 /* ── typed arrays / Buffer ─────────────────────────────────────────────── */
 /** The typed-array constructors with a runtime representation, by lib
  * interface name. Other flavors (BigInt64Array, BigUint64Array) fall through
@@ -365,6 +680,9 @@ export function lowerBytesMethodCall(lowerer, call, access) {
     if (name === "sort" || name === "toSorted") {
         return lowerBytesSortCall(lowerer, call, access, receiverIr);
     }
+    if (BYTES_CALLBACK_METHODS.has(name)) {
+        return lowerBytesCallbackCall(lowerer, call, access, name, receiverIr);
+    }
     // values()/keys()/entries() as iterator objects (for...of heads and
     // stored numeric iterators lower before this).
     if ((name === "values" || name === "keys" || name === "entries") && nArgs === 0) {
@@ -1144,6 +1462,158 @@ function knownBufferProducer(lowerer, source, seen = new Set()) {
     const type = lowerer.mapTypeOf(lowerer.typeOf(callee.expression));
     return type?.kind === "cryptoHash" || type?.kind === "cryptoHmac";
 }
+/** Buffer.from over a checked-dynamic source and encoding, both already in
+ * repeatable locals: Node's fromString takes utf8 for an absent, non-string
+ * or empty encoding and throws ERR_UNKNOWN_ENCODING for an unknown name;
+ * other sources ignore the encoding. */
+function dynBufferFromParts(source, encoding, loc) {
+    const utf8 = { kind: "strLit", value: "utf8", type: STRING, loc };
+    const isString = (x) => ({
+        kind: "dynTest",
+        test: "string",
+        value: x,
+        type: BOOL,
+        loc,
+    });
+    const name = {
+        kind: "ternary",
+        cond: {
+            kind: "logical",
+            op: "&&",
+            left: isString(encoding),
+            right: {
+                kind: "strEq",
+                negated: true,
+                left: { kind: "dynCheck", value: encoding, type: STRING, loc },
+                right: { kind: "strLit", value: "", type: STRING, loc },
+                type: BOOL,
+                loc,
+            },
+            type: BOOL,
+            loc,
+        },
+        then: { kind: "dynCheck", value: encoding, type: STRING, loc },
+        else_: utf8,
+        type: STRING,
+        loc,
+    };
+    return {
+        kind: "ternary",
+        cond: isString(source),
+        then: {
+            kind: "libCall",
+            fn: "buffer.poolFromStrChecked",
+            args: [{ kind: "dynCheck", value: source, type: STRING, loc }, name],
+            type: BYTES_U8,
+            loc,
+        },
+        else_: {
+            kind: "libCall",
+            fn: "buffer.poolFromDynRef",
+            args: [source, utf8],
+            type: BYTES_U8,
+            loc,
+        },
+        type: BYTES_U8,
+        loc,
+    };
+}
+/** Lowers `source` and `encNode` (or undefined) into hidden dyn locals, in
+ * source order, and builds the result from their references. */
+function withDynBufferArguments(lowerer, source, encNode, loc, build) {
+    const v = lowerer.declareHiddenLocal("%bufferValue", DYN);
+    const e = lowerer.declareHiddenLocal("%bufferEncoding", DYN);
+    const result = build(varRef(v.id, DYN, loc), varRef(e.id, DYN, loc));
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: v.id, init: lowerer.coerceToExpected(source, DYN), loc },
+            {
+                kind: "varDecl",
+                localId: e.id,
+                init: encNode === undefined
+                    ? dynUndefinedExpr(loc)
+                    : lowerer.coerceToExpected(lowerer.lowerExpr(encNode), DYN),
+                loc,
+            },
+        ],
+        result,
+        type: result.type,
+        loc,
+    };
+}
+/** Buffer.from(value, encoding) over a checked-dynamic value whose encoding
+ * is not a literal: yazl forwards its `encoding` parameter, often undefined.
+ * Null when the encoding is absent or a literal. */
+function dynBufferFromRuntimeEncoding(lowerer, value, encNode, loc) {
+    if (encNode === undefined || lowerer.typeOf(encNode).isStringLiteralType())
+        return null;
+    return withDynBufferArguments(lowerer, value, encNode, loc, (source, encoding) => dynBufferFromParts(source, encoding, loc));
+}
+/** The deprecated `new Buffer(arg[, encoding])` in a dependency's
+ * JavaScript, through the global or an alias of it (buffer-crc32 and yazl
+ * keep it as the fallback for runtimes without Buffer.alloc/Buffer.from).
+ * Node never emits DEP0005 for calls from node_modules, so the construction
+ * is exactly Node's: a number allocates zero-filled bytes (and throws
+ * ERR_INVALID_ARG_TYPE beside a string second argument), anything else
+ * converts as Buffer.from does. Null elsewhere: other callers owe the
+ * deprecation warning. */
+export function lowerNodeModulesBufferConstruct(lowerer, expr) {
+    const sf = expr.getSourceFile();
+    if (!isJsSourceFile(sf) || !/[\\/]node_modules[\\/]/.test(sf.fileName))
+        return null;
+    const args = expr.arguments?.nodes ?? [];
+    if (args.length < 1 || args.length > 2 || args.some(ts.isSpreadElement))
+        return null;
+    if (stdlibGlobalNameOf(lowerer, expr.expression) !== "Buffer")
+        return null;
+    const loc = locOf(expr);
+    const value = withDynBufferArguments(lowerer, lowerer.lowerExpr(args[0]), args[1], loc, (source, encoding) => ({
+        kind: "ternary",
+        cond: { kind: "dynTest", test: "number", value: source, type: BOOL, loc },
+        then: {
+            kind: "ternary",
+            cond: { kind: "dynTest", test: "string", value: encoding, type: BOOL, loc },
+            then: { kind: "libCall", fn: "buffer.newStringFail", args: [source], type: BYTES_U8, loc },
+            else_: {
+                kind: "libCall",
+                fn: "buffer.alloc",
+                args: [{ kind: "dynCheck", value: source, type: F64, loc }],
+                type: BYTES_U8,
+                loc,
+            },
+            type: BYTES_U8,
+            loc,
+        },
+        else_: dynBufferFromParts(source, encoding, loc),
+        type: BYTES_U8,
+        loc,
+    }));
+    return { kind: "libCall", fn: "buffer.brand", args: [value], type: BYTES_U8, loc };
+}
+/** Buffer.from(array or bytes, extra): Node copies an array-like source and
+ * ignores the encoding/offset argument (yazl passes its `encoding` through
+ * unchanged), but JavaScript still evaluates it after the source. */
+function withIgnoredBufferArgument(lowerer, extraNode, source, build) {
+    if (extraNode === undefined)
+        return build(source);
+    const extra = lowerer.lowerExpr(extraNode);
+    if (isSafeToDiscard(extra))
+        return build(source);
+    const loc = source.loc;
+    const tmp = lowerer.declareHiddenLocal("%bufferSource", source.type);
+    const result = build(varRef(tmp.id, source.type, loc));
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: tmp.id, init: source, loc },
+            { kind: "exprStmt", expr: extra, loc },
+        ],
+        result,
+        type: result.type,
+        loc,
+    };
+}
 export function lowerBufferStaticCall(lowerer, call, access) {
     const value = lowerBufferStaticValue(lowerer, call, access);
     // Every byte-valued Buffer factory creates a distinct view. Preserve its
@@ -1200,11 +1670,15 @@ function lowerBufferStaticValue(lowerer, call, access) {
                 !argNode.elements.nodes.some(ts.isSpreadElement)) {
                 // A number[] literal (contextually typed by the lib's readonly
                 // number[] slot — build it element-wise, the Set-seed pattern).
-                if (args.length === 1) {
-                    const elems = argNode.elements.nodes.map((el) => lowerer.lowerExprExpecting(el, F64));
-                    const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
-                    return { kind: "libCall", fn: "buffer.poolFromArray", args: [seed], type: BYTES_U8, loc };
-                }
+                const elems = argNode.elements.nodes.map((el) => lowerer.lowerExprExpecting(el, F64));
+                const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
+                return withIgnoredBufferArgument(lowerer, args[1], seed, (array) => ({
+                    kind: "libCall",
+                    fn: "buffer.poolFromArray",
+                    args: [array],
+                    type: BYTES_U8,
+                    loc,
+                }));
             }
             else {
                 const srcIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
@@ -1212,6 +1686,9 @@ function lowerBufferStaticValue(lowerer, call, access) {
                 // JS callback storage can be native DYN even when the checker
                 // reports any (or a narrowed Buffer). Dispatch on its actual ABI.
                 if (value.type.kind === "dyn") {
+                    const runtimeEncoding = dynBufferFromRuntimeEncoding(lowerer, value, args[1], loc);
+                    if (runtimeEncoding)
+                        return runtimeEncoding;
                     const encName = args[1] ? bufEncoding(lowerer, "Buffer.from", args[1]) : "utf8";
                     const enc = { kind: "strLit", value: encName, type: STRING, loc };
                     return {
@@ -1256,25 +1733,24 @@ function lowerBufferStaticValue(lowerer, call, access) {
                 // A checker type with no mapping (pako's conditional `O extends
                 // { toText: true } ? string : Uint8Array` result) whose lowered
                 // value is a u8 view copies like the typed form.
-                if (args.length === 1 &&
-                    ((srcIr?.kind === "bytes" && srcIr.elem === "u8") ||
-                        (srcIr === null && value.type.kind === "bytes" && value.type.elem === "u8"))) {
-                    return {
+                if ((srcIr?.kind === "bytes" && srcIr.elem === "u8") ||
+                    (srcIr === null && value.type.kind === "bytes" && value.type.elem === "u8")) {
+                    return withIgnoredBufferArgument(lowerer, args[1], value, (bytes) => ({
                         kind: "libCall",
                         fn: "buffer.poolFromBytes",
-                        args: [value],
+                        args: [bytes],
                         type: BYTES_U8,
                         loc,
-                    };
+                    }));
                 }
-                if (args.length === 1 && srcIr?.kind === "array" && srcIr.elem.kind === "f64") {
-                    return {
+                if (srcIr?.kind === "array" && srcIr.elem.kind === "f64") {
+                    return withIgnoredBufferArgument(lowerer, args[1], value, (array) => ({
                         kind: "libCall",
                         fn: "buffer.poolFromArray",
-                        args: [value],
+                        args: [array],
                         type: BYTES_U8,
                         loc,
-                    };
+                    }));
                 }
                 // A union of strings, u8 views and undefined/null (a JS-inferred
                 // npm result such as pako's deflate): the checked form dispatches