@scriptc/compiler 0.3.5 → 0.4.0

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

@@ -1,7 +1,7 @@
 import { dynUndefinedExpr, 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, typeEquals, } from "../../../ir/ir.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 { newFnCtx, own } from "../lowerer.js";
 import { buildBytesSortFn, closureKeyOrder } from "../lower-array-sort.js";
@@ -10,6 +10,7 @@ import { lowerDynObjectLiteral } from "../expressions/object-literals.js";
 import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, } from "../optional-arguments.js";
 import { lowerCheckedArrayFrom } from "./array-construction.js";
 import { lowerToNumberArgument } from "../lower-exprs.js";
+import { lowerBytesIteratorValue } from "../iterator-adapters.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
@@ -18,12 +19,12 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
     const loc = locOf(call);
     const method = access.name.text;
     const copyFirst = method === "toSorted";
-    if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`.${method} with ${call.arguments.length} arguments on ${BYTES_ELEMENT_NAME[bytesT.elem]}`, call);
+    if (call.arguments.nodes.length > 1 || call.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`.${method} with ${call.arguments.nodes.length} arguments on ${BYTES_ELEMENT_NAME[bytesT.elem]}`, call);
     }
     const receiver = lowerer.lowerExprExpecting(access.expression, bytesT);
-    const undefinedArg = call.arguments[0]
-        ? lowerStaticallyUndefinedArgument(lowerer, call.arguments[0])
+    const undefinedArg = call.arguments.nodes[0]
+        ? lowerStaticallyUndefinedArgument(lowerer, call.arguments.nodes[0])
         : null;
     const helperFor = (key, arity, hasComparator, order) => {
         const cacheKey = `bytes.${method}:${bytesT.elem}:${key}`;
@@ -35,7 +36,7 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
         }
         return helper;
     };
-    if (call.arguments.length === 0 || undefinedArg) {
+    if (call.arguments.nodes.length === 0 || undefinedArg) {
         const helper = helperFor("default", 0, false, null);
         if (!undefinedArg || isSafeToDiscard(undefinedArg)) {
             return { kind: "call", callee: helper, args: [receiver], type: bytesT, loc };
@@ -67,14 +68,14 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
             loc,
         };
     }
-    const argNode = call.arguments[0];
+    const argNode = call.arguments.nodes[0];
     let fnArg = lowerer.lowerExpr(argNode);
     // As for Array sort: adapt a comparator over checked values to the
     // element ABI; arithmetic on inferred JS values still yields a number.
     if (fnArg.type.kind === "func" &&
         fnArg.type.params.length <= 2 &&
         fnArg.type.params.every((param) => lowerer.coercibleValue(F64, param))) {
-        const result = fnArg.type.ret.kind === "dyn" && isJsSourceFile(argNode.getSourceFile())
+        const result = fnArg.type.ret.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(argNode))
             ? F64
             : fnArg.type.ret;
         const expected = funcOf(fnArg.type.params.map(() => F64), result);
@@ -101,7 +102,7 @@ function lowerBytesSortCall(lowerer, call, access, bytesT) {
 }
 /* ── typed arrays / Buffer ─────────────────────────────────────────────── */
 /** The typed-array constructors with a runtime representation, by lib
- * interface name. Other flavors (Float16Array, BigInt64Array, ...) fall through
+ * interface name. Other flavors (BigInt64Array, BigUint64Array) fall through
  * to the generic stdlib-constructor fence. DataView is handled separately. */
 const BYTES_CTORS = {
     Uint8Array: "u8",
@@ -111,6 +112,7 @@ const BYTES_CTORS = {
     Int16Array: "i16",
     Uint32Array: "u32",
     Int32Array: "i32",
+    Float16Array: "f16",
     Float32Array: "f32",
     Float64Array: "f64",
 };
@@ -128,9 +130,9 @@ const BYTES_CTORS = {
  * typed-array construction. */
 export function lowerBytesNew(lowerer, expr, symbol) {
     if (symbol != null &&
-        (symbol.name === "ArrayBuffer" || symbol.name === "SharedArrayBuffer") &&
+        (ts.symbolName(symbol) === "ArrayBuffer" || ts.symbolName(symbol) === "SharedArrayBuffer") &&
         lowerer.isStdlibSymbol(symbol)) {
-        const args = expr.arguments ?? [];
+        const args = expr.arguments?.nodes ?? [];
         if (args.length > 1 || args.some(ts.isSpreadElement)) {
             lowerer.noLowering("resizable ArrayBuffer construction", expr, "fixed-length ArrayBuffers accept a byte length; resizable storage is not supported yet");
         }
@@ -139,22 +141,22 @@ export function lowerBytesNew(lowerer, expr, symbol) {
             : dynUndefinedExpr(locOf(expr));
         return {
             kind: "libCall",
-            fn: symbol.name === "SharedArrayBuffer" ? "sharedArrayBuffer.new" : "arrayBuffer.new",
+            fn: ts.symbolName(symbol) === "SharedArrayBuffer" ? "sharedArrayBuffer.new" : "arrayBuffer.new",
             args: [length],
             type: DYN,
             loc: locOf(expr),
         };
     }
-    if (symbol && symbol.name === "DataView" && lowerer.isStdlibSymbol(symbol)) {
+    if (symbol && ts.symbolName(symbol) === "DataView" && lowerer.isStdlibSymbol(symbol)) {
         return lowerDataViewNew(lowerer, expr);
     }
-    const elem = symbol ? own(BYTES_CTORS, symbol.name) : undefined;
+    const elem = symbol ? own(BYTES_CTORS, ts.symbolName(symbol)) : undefined;
     if (!elem || !symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
-    const name = symbol.name;
+    const name = ts.symbolName(symbol);
     const type = bytesOf(elem);
     const loc = locOf(expr);
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (args.length === 0)
         return { kind: "bytesNew", source: null, type, loc };
     if (args.length >= 2 && args.length <= 3 && !args.some(ts.isSpreadElement)) {
@@ -162,8 +164,8 @@ export function lowerBytesNew(lowerer, expr, symbol) {
     }
     if (args.length === 1 && !ts.isSpreadElement(args[0])) {
         const argNode = args[0];
-        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
-            const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, F64));
+        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.nodes.some(ts.isSpreadElement)) {
+            const elems = argNode.elements.nodes.map((el) => lowerer.lowerExprExpecting(el, F64));
             const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
             return { kind: "bytesNew", source: seed, type, loc };
         }
@@ -197,9 +199,9 @@ export function lowerBytesStaticCall(lowerer, call, access) {
     if (lowerer.chainBlocked(call, access))
         return null;
     if (lowerer.isStdlibGlobal(access.expression, "ArrayBuffer") && access.name.text === "isView") {
-        if (call.arguments.length !== 1 || call.arguments.some(ts.isSpreadElement))
+        if (call.arguments.nodes.length !== 1 || call.arguments.nodes.some(ts.isSpreadElement))
             lowerer.noLowering("ArrayBuffer.isView argument count", call);
-        const arg = call.arguments[0];
+        const arg = call.arguments.nodes[0];
         return {
             kind: "libCall",
             fn: "arrayBuffer.isView",
@@ -211,17 +213,17 @@ export function lowerBytesStaticCall(lowerer, call, access) {
     if (access.name.text !== "from" || !ts.isIdentifier(access.expression))
         return null;
     const symbol = lowerer.resolveValueSymbol(access.expression);
-    const elem = symbol ? own(BYTES_CTORS, symbol.name) : undefined;
+    const elem = symbol ? own(BYTES_CTORS, ts.symbolName(symbol)) : undefined;
     if (!elem || !lowerer.isStdlibSymbol(symbol ?? undefined))
         return null;
-    if (call.arguments.length < 1 ||
-        call.arguments.length > 3 ||
-        call.arguments.some(ts.isSpreadElement)) {
+    if (call.arguments.nodes.length < 1 ||
+        call.arguments.nodes.length > 3 ||
+        call.arguments.nodes.some(ts.isSpreadElement)) {
         lowerer.noLowering("TypedArray.from with this argument count", call);
     }
-    const node = call.arguments[0];
+    const node = call.arguments.nodes[0];
     const source = lowerer.lowerExpr(node);
-    if (call.arguments.length > 1) {
+    if (call.arguments.nodes.length > 1) {
         if (!["string", "array", "bytes"].includes(source.type.kind))
             lowerer.noLowering("TypedArray.from mapper over this source representation", call);
         const loc = locOf(call);
@@ -268,9 +270,9 @@ export function lowerBytesStaticCall(lowerer, call, access) {
             callee: key,
             args: [
                 lowerer.coerceInto(node, source, DYN),
-                lowerer.lowerExprExpecting(call.arguments[1], DYN),
-                call.arguments[2]
-                    ? lowerer.lowerExprExpecting(call.arguments[2], DYN)
+                lowerer.lowerExprExpecting(call.arguments.nodes[1], DYN),
+                call.arguments.nodes[2]
+                    ? lowerer.lowerExprExpecting(call.arguments.nodes[2], DYN)
                     : dynUndefinedExpr(loc),
             ],
             type: bytesOf(elem),
@@ -303,6 +305,7 @@ function lowerArrayBufferView(lowerer, args, elem, loc) {
         u8: "arrayBuffer.viewU8",
         u32: "arrayBuffer.viewU32",
         i32: "arrayBuffer.viewI32",
+        f16: "arrayBuffer.viewF16",
         f32: "arrayBuffer.viewF32",
         f64: "arrayBuffer.viewF64",
         dv: "arrayBuffer.viewDV",
@@ -316,7 +319,7 @@ function lowerArrayBufferView(lowerer, args, elem, loc) {
     };
 }
 function lowerDataViewNew(lowerer, expr) {
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (!args.length || args.length > 3 || args.some(ts.isSpreadElement))
         lowerer.noLowering("DataView constructor argument count", expr);
     return lowerArrayBufferView(lowerer, args, "dv", locOf(expr));
@@ -338,10 +341,10 @@ export function lowerBytesMethodCall(lowerer, call, access) {
     if (!lowerer.isStdlibMember(access))
         return null;
     const loc = locOf(call);
-    const nArgs = call.arguments.length;
+    const nArgs = call.arguments.nodes.length;
     // Encoded stream callbacks can receive strings even when JavaScript's
     // contextual inference still describes their parameter as a Buffer.
-    if (name === "toString" && nArgs <= 1 && isJsSourceFile(call.getSourceFile())) {
+    if (name === "toString" && nArgs <= 1 && isJsSourceFile(ts.getSourceFileOfNode(call))) {
         const lowered = lowerer.lowerExpr(access.expression);
         const receiver = lowered.kind === "dynCheck" && lowered.value.type.kind === "dyn" ? lowered.value : lowered;
         if (receiver.type.kind === "dyn")
@@ -350,10 +353,10 @@ export function lowerBytesMethodCall(lowerer, call, access) {
                 fn: "dyn.toString",
                 args: [
                     receiver,
-                    call.arguments[0]
-                        ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
+                    call.arguments.nodes[0]
+                        ? lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN)
                         : dynUndefinedExpr(loc),
-                    { kind: "strLit", value: access.getText(), type: STRING, loc },
+                    { kind: "strLit", value: ts.getTextOfNode(access), type: STRING, loc },
                 ],
                 type: STRING,
                 loc,
@@ -362,6 +365,16 @@ export function lowerBytesMethodCall(lowerer, call, access) {
     if (name === "sort" || name === "toSorted") {
         return lowerBytesSortCall(lowerer, call, access, 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) {
+        const type = lowerer.mapTypeOf(lowerer.typeOf(call));
+        if (type?.kind === "generator") {
+            const value = lowerBytesIteratorValue(lowerer, lowerer.lowerExpr(access.expression), name, type, loc);
+            if (value)
+                return value;
+        }
+    }
     if (name === "toReversed") {
         if (nArgs !== 0) {
             lowerer.noLowering(`.toReversed with ${nArgs} arguments on typed arrays`, call);
@@ -376,7 +389,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         };
     }
     if (receiverIr.elem === "u8" && name === "with") {
-        if (nArgs !== 2 || call.arguments.some(ts.isSpreadElement)) {
+        if (nArgs !== 2 || call.arguments.nodes.some(ts.isSpreadElement)) {
             lowerer.noLowering(`.with with ${nArgs} arguments on Uint8Array`, call);
         }
         return {
@@ -384,15 +397,15 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             method: "with",
             receiver: lowerer.lowerExprExpecting(access.expression, receiverIr),
             args: [
-                lowerer.lowerExprExpecting(call.arguments[0], F64),
-                lowerer.lowerExprExpecting(call.arguments[1], F64),
+                lowerer.lowerExprExpecting(call.arguments.nodes[0], F64),
+                lowerer.lowerExprExpecting(call.arguments.nodes[1], F64),
             ],
             type: receiverIr,
             loc,
         };
     }
     if (name === "join") {
-        if (nArgs > 1 || call.arguments.some(ts.isSpreadElement)) {
+        if (nArgs > 1 || call.arguments.nodes.some(ts.isSpreadElement)) {
             lowerer.noLowering(`.join with ${nArgs} arguments on typed arrays`, call);
         }
         const separatorDefault = {
@@ -401,8 +414,8 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             type: STRING,
             loc,
         };
-        const separator = call.arguments[0]
-            ? lowerOptionalArgument(lowerer, call.arguments[0], STRING, separatorDefault)
+        const separator = call.arguments.nodes[0]
+            ? lowerOptionalArgument(lowerer, call.arguments.nodes[0], STRING, separatorDefault)
             : separatorDefault;
         return {
             kind: "bytesIntrinsic",
@@ -420,7 +433,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         // A missing start is 0 and a missing end is the length (+Infinity
         // clamps to it), as for omitted arguments.
-        const args = call.arguments.map((a, i) => lowerOptionalArgument(lowerer, a, F64, {
+        const args = call.arguments.nodes.map((a, i) => lowerOptionalArgument(lowerer, a, F64, {
             kind: "numLit",
             value: i === 0 ? 0 : Infinity,
             type: F64,
@@ -434,21 +447,19 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             (() => {
                 const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
                 return (nameSym !== undefined &&
-                    lowerer.checker
-                        .declarationsOf(nameSym)
-                        .some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"));
+                    nameSym.declarations.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 === "copyWithin") {
-        if (nArgs > 3 || call.arguments.some(ts.isSpreadElement)) {
+        if (nArgs > 3 || call.arguments.nodes.some(ts.isSpreadElement)) {
             lowerer.noLowering(`.copyWithin with ${nArgs} arguments on typed arrays`, call);
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const args = [0, 0, Infinity].map((value, i) => {
             const fallback = { kind: "numLit", value, type: F64, loc };
-            const node = call.arguments[i];
+            const node = call.arguments.nodes[i];
             return node ? lowerOptionalArgument(lowerer, node, F64, fallback) : fallback;
         });
         return { kind: "bytesIntrinsic", method: "copyWithin", receiver, args, type: receiverIr, loc };
@@ -457,22 +468,20 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         !(() => {
             const symbol = lowerer.checker.getSymbolAtLocation(access.name);
             return (symbol !== undefined &&
-                lowerer.checker
-                    .declarationsOf(symbol)
-                    .some((declaration) => ts.isInterfaceDeclaration(declaration.parent) &&
+                symbol.declarations.some((declaration) => ts.isInterfaceDeclaration(declaration.parent) &&
                     declaration.parent.name.text === "Buffer"));
         })()) {
         // Typed arrays use element coercion and relative, clamped indices.
         // Buffer's same-named method keeps its pattern and offset validation.
-        if (nArgs > 3 || call.arguments.some(ts.isSpreadElement)) {
+        if (nArgs > 3 || call.arguments.nodes.some(ts.isSpreadElement)) {
             lowerer.noLowering(`.fill with ${nArgs} arguments on typed arrays`, call);
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const zero = { kind: "numLit", value: 0, type: F64, loc };
-        const v = call.arguments[0]
-            ? lowerOptionalArgument(lowerer, call.arguments[0], F64, zero)
+        const v = call.arguments.nodes[0]
+            ? lowerOptionalArgument(lowerer, call.arguments.nodes[0], F64, zero)
             : zero;
-        const idx = call.arguments.slice(1).map((a, i) => lowerOptionalArgument(lowerer, a, F64, {
+        const idx = call.arguments.nodes.slice(1).map((a, i) => lowerOptionalArgument(lowerer, a, F64, {
             kind: "numLit",
             value: i === 0 ? 0 : Infinity,
             type: F64,
@@ -492,13 +501,13 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             lowerer.noLowering(`.set with ${nArgs} arguments on typed arrays`, call);
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
-        const src = lowerer.lowerExpr(call.arguments[0]);
+        const src = lowerer.lowerExpr(call.arguments.nodes[0]);
         const method = src.type.kind === "bytes" ? "setFrom" : "setFromDyn";
         const args = [
-            src.type.kind === "bytes" ? src : lowerer.coerceInto(call.arguments[0], src, DYN),
+            src.type.kind === "bytes" ? src : lowerer.coerceInto(call.arguments.nodes[0], src, DYN),
         ];
         if (nArgs === 2)
-            args.push(lowerOptionalArgument(lowerer, call.arguments[1], F64, {
+            args.push(lowerOptionalArgument(lowerer, call.arguments.nodes[1], F64, {
                 kind: "numLit",
                 value: 0,
                 type: F64,
@@ -513,9 +522,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         const declaredOnBuffer = (() => {
             const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
             return (nameSym !== undefined &&
-                lowerer.checker
-                    .declarationsOf(nameSym)
-                    .some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"));
+                nameSym.declarations.some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"));
         })();
         if (receiverIr.elem !== "u8" || !declaredOnBuffer) {
             lowerer.noLowering("typed-array toString", call, 'Buffer.from(x).toString("utf8" | "hex" | "base64") is the lowered string conversion');
@@ -523,7 +530,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs > 3)
             lowerer.noLowering(`.toString with ${nArgs} arguments on Buffers`, call);
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
-        const encNode = call.arguments[0];
+        const encNode = call.arguments.nodes[0];
         let method = "toString";
         let enc = { kind: "strLit", value: "utf8", type: STRING, loc };
         if (encNode) {
@@ -563,9 +570,9 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         // receiver's length, because EXPLICIT negative ends clamp to empty
         // in Node and no in-band sentinel can represent "omitted" safely.
         if (nArgs > 1) {
-            const start = lowerer.lowerExprExpecting(call.arguments[1], F64);
+            const start = lowerer.lowerExprExpecting(call.arguments.nodes[1], F64);
             if (nArgs === 3) {
-                const end = lowerer.lowerExprExpecting(call.arguments[2], F64);
+                const end = lowerer.lowerExprExpecting(call.arguments.nodes[2], F64);
                 return {
                     kind: "bytesIntrinsic",
                     method,
@@ -588,9 +595,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
     const declOnBuffer = (() => {
         const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
         return (nameSym !== undefined &&
-            lowerer.checker
-                .declarationsOf(nameSym)
-                .some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"));
+            nameSym.declarations.some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer"));
     })();
     if (declOnBuffer && receiverIr.elem === "u8") {
         const bufMethod = lowerBufferInstanceMethod(lowerer, call, access, name, loc);
@@ -605,7 +610,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
-        const offsetNode = call.arguments[required];
+        const offsetNode = call.arguments.nodes[required];
         const offset = offsetNode
             ? lowerer.lowerExprExpecting(offsetNode, F64)
             : { kind: "numLit", value: 0, type: F64, loc };
@@ -620,7 +625,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
                 loc,
             };
         }
-        const value = lowerer.lowerExprExpecting(call.arguments[0], BIGINT_T);
+        const value = lowerer.lowerExprExpecting(call.arguments.nodes[0], BIGINT_T);
         return {
             kind: "libCall",
             fn: "bigint.bufferWrite",
@@ -645,7 +650,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const kind = { kind: "strLit", value: numKind, type: STRING, loc };
-        const args = [kind, ...call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64))];
+        const args = [kind, ...call.arguments.nodes.map((a) => lowerer.lowerExprExpecting(a, F64))];
         if (nArgs === required) {
             args.push({ kind: "numLit", value: 0, type: F64, loc }); // Node's offset default
         }
@@ -670,7 +675,7 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         const kind = { kind: "strLit", value: varKind, type: STRING, loc };
-        const args = [kind, ...call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64))];
+        const args = [kind, ...call.arguments.nodes.map((a) => lowerer.lowerExprExpecting(a, F64))];
         return {
             kind: "bytesIntrinsic",
             method: write ? "writeNumVar" : "readNumVar",
@@ -690,10 +695,10 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs < 1 || nArgs > 2)
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
-        const offset = lowerer.lowerExprExpecting(call.arguments[0], F64);
+        const offset = lowerer.lowerExprExpecting(call.arguments.nodes[0], F64);
         const sign = { kind: "boolLit", value: dvBigGetter.sign, type: BOOL, loc };
-        const le = call.arguments[1]
-            ? lowerer.lowerExprExpecting(call.arguments[1], BOOL)
+        const le = call.arguments.nodes[1]
+            ? lowerer.lowerExprExpecting(call.arguments.nodes[1], BOOL)
             : { kind: "boolLit", value: false, type: BOOL, loc };
         return {
             kind: "libCall",
@@ -711,9 +716,9 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         }
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
         // ToIndex(undefined) is ToIndex(NaN): a missing offset reads offset 0.
-        const args = [lowerToNumberArgument(lowerer, call.arguments[0])];
+        const args = [lowerToNumberArgument(lowerer, call.arguments.nodes[0])];
         if (nArgs === 2)
-            args.push(lowerer.lowerExprExpecting(call.arguments[1], BOOL));
+            args.push(lowerer.lowerExprExpecting(call.arguments.nodes[1], BOOL));
         return { kind: "bytesIntrinsic", method: dvGetter.method, receiver, args, type: F64, loc };
     }
     // DataView setters — the getters' mirror: (byteOffset, value) plus the
@@ -727,10 +732,10 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         if (nArgs < 2 || nArgs > 3)
             lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
         const receiver = lowerer.lowerExprExpecting(access.expression, receiverIr);
-        const offset = lowerer.lowerExprExpecting(call.arguments[0], F64);
-        const value = lowerer.lowerExprExpecting(call.arguments[1], BIGINT_T);
-        const le = call.arguments[2]
-            ? lowerer.lowerExprExpecting(call.arguments[2], BOOL)
+        const offset = lowerer.lowerExprExpecting(call.arguments.nodes[0], F64);
+        const value = lowerer.lowerExprExpecting(call.arguments.nodes[1], BIGINT_T);
+        const le = call.arguments.nodes[2]
+            ? lowerer.lowerExprExpecting(call.arguments.nodes[2], BOOL)
             : { kind: "boolLit", value: false, type: BOOL, loc };
         return {
             kind: "libCall",
@@ -749,11 +754,11 @@ export function lowerBytesMethodCall(lowerer, call, access) {
         // The offset (ToIndex) and the value (ToNumber) treat a missing value
         // as NaN.
         const args = [
-            lowerToNumberArgument(lowerer, call.arguments[0]),
-            lowerToNumberArgument(lowerer, call.arguments[1]),
+            lowerToNumberArgument(lowerer, call.arguments.nodes[0]),
+            lowerToNumberArgument(lowerer, call.arguments.nodes[1]),
         ];
         if (nArgs === 3)
-            args.push(lowerer.lowerExprExpecting(call.arguments[2], BOOL));
+            args.push(lowerer.lowerExprExpecting(call.arguments.nodes[2], BOOL));
         return { kind: "bytesIntrinsic", method: dvSetter.method, receiver, args, type: VOID, loc };
     }
     return null;
@@ -828,7 +833,7 @@ const BUF_NUM_VAR_METHODS = {
  * (bufEncoding's fence); a trailing string-typed argument is the
  * encoding, exactly Node's overloads. */
 function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
-    const args = call.arguments;
+    const args = call.arguments.nodes;
     const nArgs = args.length;
     if (args.some(ts.isSpreadElement))
         return null;
@@ -876,10 +881,12 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             lowerer.noLowering(`.compare with ${nArgs} arguments`, call);
         const fast = nArgs >= 1 &&
             argIrKind(0)?.kind === "bytes" &&
-            call.arguments.slice(1).every((a) => lowerer.mapTypeOf(lowerer.typeOf(a))?.kind === "f64");
+            call.arguments.nodes
+                .slice(1)
+                .every((a) => lowerer.mapTypeOf(lowerer.typeOf(a))?.kind === "f64");
         if (fast) {
             const target = u8Arg(0);
-            const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
+            const idx = call.arguments.nodes.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
             const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
             return {
                 kind: "bytesIntrinsic",
@@ -960,7 +967,7 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
             lowerer.noLowering(`.fill with ${nArgs} arguments`, call);
         // A trailing string-typed arg past the value is the encoding.
         let encNode;
-        let idxNodes = call.arguments.slice(1);
+        let idxNodes = call.arguments.nodes.slice(1);
         if (idxNodes.length > 0 && isStringArg(nArgs - 1)) {
             encNode = idxNodes[idxNodes.length - 1];
             idxNodes = idxNodes.slice(0, -1);
@@ -1013,7 +1020,7 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
         if (nArgs < 1 || nArgs > 4)
             lowerer.noLowering(`.copy with ${nArgs} arguments`, call);
         const target = u8Arg(0);
-        const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
+        const idx = call.arguments.nodes.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
         const receiver = lowerer.lowerExprExpecting(access.expression, BYTES_U8);
         return {
             kind: "bytesIntrinsic",
@@ -1036,7 +1043,7 @@ function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
         // (str), (str, enc), (str, offset), (str, offset, enc),
         // (str, offset, length), (str, offset, length, enc).
         let encNode;
-        let idxNodes = call.arguments.slice(1);
+        let idxNodes = call.arguments.nodes.slice(1);
         if (idxNodes.length > 0 && isStringArg(nArgs - 1)) {
             encNode = idxNodes[idxNodes.length - 1];
             idxNodes = idxNodes.slice(0, -1);
@@ -1081,6 +1088,7 @@ const DV_GETTERS = {
     getInt16: { method: "dvGetInt16", le: true },
     getUint32: { method: "dvGetUint32", le: true },
     getInt32: { method: "dvGetInt32", le: true },
+    getFloat16: { method: "dvGetFloat16", le: true },
     getFloat32: { method: "dvGetFloat32", le: true },
     getFloat64: { method: "dvGetFloat64", le: true },
 };
@@ -1091,6 +1099,7 @@ const DV_SETTERS = {
     setInt16: { method: "dvSetInt16", le: true },
     setUint32: { method: "dvSetUint32", le: true },
     setInt32: { method: "dvSetInt32", le: true },
+    setFloat16: { method: "dvSetFloat16", le: true },
     setFloat32: { method: "dvSetFloat32", le: true },
     setFloat64: { method: "dvSetFloat64", le: true },
 };
@@ -1107,9 +1116,7 @@ function knownBufferProducer(lowerer, source, seen = new Set()) {
         if (!symbol || seen.has(symbol))
             return false;
         seen.add(symbol);
-        return lowerer.checker
-            .declarationsOf(symbol)
-            .some((decl) => ts.isVariableDeclaration(decl) &&
+        return symbol.declarations.some((decl) => ts.isVariableDeclaration(decl) &&
             ts.isVariableDeclarationList(decl.parent) &&
             (decl.parent.flags & ts.NodeFlags.Const) !== 0 &&
             decl.initializer !== undefined &&
@@ -1132,7 +1139,7 @@ function knownBufferProducer(lowerer, source, seen = new Set()) {
         return true;
     if (!ts.isPropertyAccessExpression(callee) ||
         callee.name.text !== "digest" ||
-        node.arguments.length !== 0)
+        node.arguments.nodes.length !== 0)
         return false;
     const type = lowerer.mapTypeOf(lowerer.typeOf(callee.expression));
     return type?.kind === "cryptoHash" || type?.kind === "cryptoHmac";
@@ -1152,12 +1159,13 @@ function lowerBufferStaticValue(lowerer, call, access) {
         return null;
     const member = access.name.text;
     const loc = locOf(call);
-    const args = call.arguments;
+    const args = call.arguments.nodes;
     if (member === "from") {
         if (args.length >= 1 &&
             args.length <= 3 &&
             !args.some(ts.isSpreadElement) &&
-            ((symbol) => symbol != null && (symbol.name === "ArrayBuffer" || symbol.name === "SharedArrayBuffer"))(lowerer.typeOf(args[0]).getSymbol())) {
+            ((symbol) => symbol != null &&
+                (ts.symbolName(symbol) === "ArrayBuffer" || ts.symbolName(symbol) === "SharedArrayBuffer"))(lowerer.typeOf(args[0]).getSymbol())) {
             return lowerArrayBufferView(lowerer, args, "u8", loc);
         }
         // Buffer.from(x.buffer[, byteOffset[, length]]): a u8 VIEW sharing
@@ -1188,11 +1196,12 @@ function lowerBufferStaticValue(lowerer, call, access) {
         }
         if (args.length >= 1 && args.length <= 2 && !args.some(ts.isSpreadElement)) {
             const argNode = args[0];
-            if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
+            if (ts.isArrayLiteralExpression(argNode) &&
+                !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.map((el) => lowerer.lowerExprExpecting(el, F64));
+                    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 };
                 }
@@ -1244,7 +1253,12 @@ function lowerBufferStaticValue(lowerer, call, access) {
                     }
                     return { kind: "libCall", fn, args: [s, enc], type: BYTES_U8, loc };
                 }
-                if (args.length === 1 && srcIr?.kind === "bytes" && srcIr.elem === "u8") {
+                // 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 {
                         kind: "libCall",
                         fn: "buffer.poolFromBytes",
@@ -1262,6 +1276,29 @@ function lowerBufferStaticValue(lowerer, call, access) {
                         loc,
                     };
                 }
+                // A union of strings, u8 views and undefined/null (a JS-inferred
+                // npm result such as pako's deflate): the checked form dispatches
+                // on the runtime kind exactly as for an untyped JS value, Node's
+                // TypeError for the unit arms included.
+                if (args.length === 1 &&
+                    value.type.kind === "union" &&
+                    lowerer.dynConvertible(value.type) &&
+                    lowerer.unions
+                        .get(value.type.unionId)
+                        ?.arms.every((arm) => arm.kind === "string" ||
+                        (arm.kind === "bytes" && arm.elem === "u8") ||
+                        isUnitType(arm)) === true) {
+                    return {
+                        kind: "libCall",
+                        fn: "buffer.poolFromDyn",
+                        args: [
+                            lowerer.coerceToExpected(value, DYN),
+                            { kind: "strLit", value: "utf8", type: STRING, loc },
+                        ],
+                        type: BYTES_U8,
+                        loc,
+                    };
+                }
             }
         }
         lowerer.noLowering("Buffer.from with this argument shape", call, "supported: Buffer.from(string, encoding?), Buffer.from(u8Array) — a copy — " +
@@ -1333,14 +1370,29 @@ function lowerBufferStaticValue(lowerer, call, access) {
         }
         const argNode = args[0];
         let list;
-        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
-            const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, BYTES_U8));
+        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.nodes.some(ts.isSpreadElement)) {
+            const elems = argNode.elements.nodes.map((el) => lowerer.lowerExprExpecting(el, BYTES_U8));
             list = { kind: "arrayLit", elems, type: arrayOf(BYTES_U8), loc };
         }
         else {
             list = lowerer.lowerExpr(argNode);
             if (!typeEquals(list.type, arrayOf(BYTES_U8))) {
-                lowerer.noLowering(`Buffer.concat of '${lowerer.fmt(list.type)}' values`, argNode, "one Uint8Array[]/Buffer[] value (or literal) is the lowered list shape");
+                // Any other list (JavaScript's untyped `const chunks = []`, or a
+                // union of arrays): the runtime checks it as Node does (an Array of
+                // Uint8Arrays, the ERR_INVALID_ARG_TYPE errors otherwise) before
+                // concatenating.
+                const value = list.type.kind === "dyn" ? list : { kind: "dynFrom", value: list, type: DYN, loc };
+                if (args.length === 2) {
+                    const total = lowerer.lowerExprExpecting(args[1], F64);
+                    return {
+                        kind: "libCall",
+                        fn: "buffer.concatLenDyn",
+                        args: [value, total],
+                        type: BYTES_U8,
+                        loc,
+                    };
+                }
+                return { kind: "libCall", fn: "buffer.concatDyn", args: [value], type: BYTES_U8, loc };
             }
         }
         if (args.length === 2) {
@@ -1406,7 +1458,9 @@ function lowerBufferStaticValue(lowerer, call, access) {
             // Untyped stream chunks retain the native checked value's Buffer
             // flavor. Plain bytes are Uint8Arrays at this boundary; inspecting
             // only the bytes tag would incorrectly identify them as Buffers.
-            const checked = isJsSourceFile(call.getSourceFile()) && v.kind === "dynCheck" && v.value.type.kind === "dyn"
+            const checked = isJsSourceFile(ts.getSourceFileOfNode(call)) &&
+                v.kind === "dynCheck" &&
+                v.value.type.kind === "dyn"
                 ? v.value
                 : v;
             if (checked.type.kind === "dyn") {
@@ -1446,6 +1500,12 @@ function lowerBufferStaticValue(lowerer, call, access) {
                     };
                 }
             }
+            // A typed view of unknown provenance (a Uint8Array parameter,
+            // safe-buffer's Buffer.from result): Buffer is a brand of the view,
+            // which the runtime keeps, so the test reads it.
+            if (v.type.kind === "bytes") {
+                return { kind: "libCall", fn: "buffer.isBranded", args: [v], type: BOOL, loc };
+            }
             lowerer.noLowering(`Buffer.isBuffer of '${lowerer.fmt(v.type)}' values`, args[0], "the check lowers as a runtime tag test on unions with a Buffer arm — here the answer is static");
         }
         lowerer.noLowering("Buffer.isBuffer with this argument shape", call);