watr 4.2.0 → 4.3.0

package/dist/watr.js

@@ -18,7 +18,7 @@ __export(encode_exports, {
 });
 
 // src/util.js
-var err = (text, pos = err.i) => {
+var err = (text, pos = err.loc) => {
   if (pos != null && err.src) {
     let line = 1, col = 1;
     for (let i = 0; i < pos && i < err.src.length; i++) {
@@ -447,13 +447,14 @@ var INSTR = [
   ,
   ,
   ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
+  // 0xe0-0xe6: stack switching (Phase 3)
+  "cont.new typeidx",
+  "cont.bind cont_bind",
+  "suspend tagidx",
+  "resume resume",
+  "resume_throw resume_throw",
+  "resume_throw_ref resume_throw_ref",
+  "switch switch_cont",
   ,
   ,
   ,
@@ -506,7 +507,15 @@ var INSTR = [
     "extern.convert_any",
     "ref.i31",
     "i31.get_s",
-    "i31.get_u"
+    "i31.get_u",
+    ,
+    "struct.new_desc typeidx",
+    "struct.new_default_desc typeidx",
+    "ref.get_desc typeidx",
+    "ref.cast_desc_eq reftype",
+    ,
+    "br_on_cast_desc_eq reftype2",
+    "br_on_cast_desc_eq_fail reftype2"
   ],
   // 0xfc: Bulk memory/table operations (nested array)
   [
@@ -920,6 +929,9 @@ var TYPE = {
   i31: 108,
   struct: 107,
   array: 106,
+  cont: 104,
+  nocont: 117,
+  // stack switching (Phase 3)
   // Reference type abbreviations (absheaptype abbrs)
   nullfuncref: 115,
   nullexternref: 114,
@@ -933,6 +945,9 @@ var TYPE = {
   i31ref: 108,
   structref: 107,
   arrayref: 106,
+  contref: 104,
+  nocontref: 117,
+  // stack switching abbreviations
   // ref, refnull
   ref: 100,
   // -0x1c
@@ -943,7 +958,7 @@ var TYPE = {
   subfinal: 79,
   rec: 78
 };
-var DEFTYPE = { func: 96, struct: 95, array: 94, sub: 80, subfinal: 79, rec: 78 };
+var DEFTYPE = { func: 96, struct: 95, array: 94, cont: 93, sub: 80, subfinal: 79, rec: 78 };
 var KIND = { func: 0, table: 1, memory: 2, global: 3, tag: 4 };
 
 // src/parse.js
@@ -951,7 +966,7 @@ var parse_default = (str2) => {
   let i = 0, level = [], buf = "", q = 0, depth = 0;
   const commit = () => buf && (level.push(buf), buf = "");
   const parseLevel = (pos) => {
-    level.i = pos;
+    level.loc = pos;
     for (let c, root, p; i < str2.length; ) {
       c = str2.charCodeAt(i);
       if (q === 34) buf += str2[i++], c === 92 ? buf += str2[i++] : c === 34 && (commit(), q = 0);
@@ -996,48 +1011,79 @@ var cleanup = (node, result) => !Array.isArray(node) ? typeof node !== "string"
 ) : (
   // remove annotations like (@name ...) except @custom and @metadata.code.*
   node[0]?.[0] === "@" && node[0] !== "@custom" && !node[0]?.startsWith?.("@metadata.code.") ? null : (
-    // unwrap single-element array containing module (after removing comments), preserve .i
-    (result = node.map(cleanup).filter((n) => n != null), result.i = node.i, result.length === 1 && result[0]?.[0] === "module" ? result[0] : result)
+    // unwrap single-element array containing module (after removing comments), preserve .loc
+    (result = node.map(cleanup).filter((n) => n != null), result.loc = node.loc, result.length === 1 && result[0]?.[0] === "module" ? result[0] : result)
   )
 );
 function compile(nodes) {
   if (typeof nodes === "string") err.src = nodes, nodes = parse_default(nodes) || [];
   else err.src = "";
-  err.i = 0;
+  err.loc = 0;
   nodes = cleanup(nodes) || [];
   let idx = 0;
   if (nodes[0] === "module") idx++, isId(nodes[idx]) && idx++;
   else if (typeof nodes[0] === "string") nodes = [nodes];
   if (nodes[idx] === "binary") return Uint8Array.from(nodes.slice(++idx).flat());
   if (nodes[idx] === "quote") return compile(nodes.slice(++idx).map((v) => v.valueOf().slice(1, -1)).flat().join(""));
+  nodes = nodes.flatMap((n, i) => {
+    if (i < idx || !Array.isArray(n) || n[0] !== "import") return [n];
+    const [, mod, ...rest] = n;
+    if (!rest.some((r) => Array.isArray(r) && r[0] === "item")) return [n];
+    const lastIsType = Array.isArray(rest.at(-1)) && rest.at(-1)[0] !== "item";
+    if (lastIsType) {
+      const type = rest.at(-1);
+      return rest.slice(0, -1).filter((r) => r[0] === "item").map(([, nm]) => ["import", mod, nm, type]);
+    }
+    return rest.filter((r) => r[0] === "item").map(([, nm, type]) => ["import", mod, nm, type]);
+  });
   const ctx = [];
   for (let kind in SECTION) (ctx[SECTION[kind]] = ctx[kind] = []).name = kind;
   ctx.metadata = {};
   nodes.slice(idx).filter((n) => {
     if (!Array.isArray(n)) {
-      let pos = err.src?.indexOf(n, err.i);
-      if (pos >= 0) err.i = pos;
+      let pos = err.loc, src = err.src, c;
+      while ((pos = src.indexOf(n, pos)) >= 0) {
+        c = src.charCodeAt(pos - 1);
+        if (pos > 0 && (c > 47 && c < 58 || c > 64 && c < 91 || c > 96 && c < 123 || c === 95 || c === 36)) {
+          pos++;
+          continue;
+        }
+        c = src.charCodeAt(pos + n.length);
+        if (c > 47 && c < 58 || c > 64 && c < 91 || c > 96 && c < 123 || c === 95) {
+          pos++;
+          continue;
+        }
+        break;
+      }
+      if (pos >= 0) err.loc = pos;
       err(`Unexpected token ${n}`);
     }
     let [kind, ...node] = n;
-    err.i = n.i;
+    err.loc = n.loc;
     if (kind === "@custom") {
       ctx.custom.push(node);
     } else if (kind === "rec") {
       for (let i = 0; i < node.length; i++) {
         let [, ...subnode] = node[i];
         name(subnode, ctx.type);
+        const tdesc = [];
+        while (subnode[0]?.[0] === "descriptor" || subnode[0]?.[0] === "describes") tdesc.push(subnode.shift());
         (subnode = typedef(subnode, ctx)).push(i ? true : [ctx.type.length, node.length]);
+        if (tdesc.length) subnode.desc = subnode.desc ? [...tdesc, ...subnode.desc] : tdesc;
         ctx.type.push(subnode);
       }
     } else if (kind === "type") {
       name(node, ctx.type);
-      ctx.type.push(typedef(node, ctx));
+      const tdesc = [];
+      while (node[0]?.[0] === "descriptor" || node[0]?.[0] === "describes") tdesc.push(node.shift());
+      const td = typedef(node, ctx);
+      if (tdesc.length) td.desc = td.desc ? [...tdesc, ...td.desc] : tdesc;
+      ctx.type.push(td);
     } else if (kind === "start" || kind === "export") ctx[kind].push(node);
     else return true;
   }).forEach((n) => {
     let [kind, ...node] = n;
-    err.i = n.i;
+    err.loc = n.loc;
     let imported;
     if (kind === "import") [kind, ...node] = (imported = node).pop();
     let items = ctx[kind];
@@ -1055,7 +1101,8 @@ function compile(nodes) {
     } else if (kind === "memory") {
       const is64 = node[0] === "i64", idx2 = is64 ? 1 : 0;
       if (node[idx2]?.[0] === "data") {
-        let [, ...data] = node.splice(idx2, 1)[0], m = "" + Math.ceil(data.reduce((s, d) => s + d.length, 0) / 65536);
+        const ps = node.find((n2) => Array.isArray(n2) && n2[0] === "pagesize")?.[1] ?? 65536;
+        let [, ...data] = node.splice(idx2, 1)[0], m = "" + Math.ceil(data.reduce((s, d) => s + d.length, 0) / ps);
         ctx.data.push([["memory", items.length], [is64 ? "i64.const" : "i32.const", is64 ? 0n : 0], ...data]);
         node = is64 ? ["i64", m, m] : [m, m];
       }
@@ -1147,7 +1194,7 @@ function normalize(nodes, ctx) {
       } else if ((node.startsWith("memory.") || node.endsWith("load") || node.endsWith("store")) && isIdx(nodes[0])) out.push(nodes.shift());
     } else if (Array.isArray(node)) {
       const op = node[0];
-      node.i != null && (err.i = node.i);
+      node.loc != null && (err.loc = node.loc);
       if (op?.startsWith?.("@metadata.code.")) {
         let type = op.slice(15);
         out.push(["@metadata", type, node[1]]);
@@ -1182,7 +1229,7 @@ function normalize(nodes, ctx) {
         out.push(...normalize(parts, ctx), "end");
       } else {
         const imm = [];
-        while (parts.length && (!Array.isArray(parts[0]) || "type,param,result,ref".includes(parts[0][0]))) imm.push(parts.shift());
+        while (parts.length && (!Array.isArray(parts[0]) || "type,param,result,ref,exact,on".includes(parts[0][0]))) imm.push(parts.shift());
         out.push(...normalize(parts, ctx), op, ...imm);
         nodes.unshift(...out.splice(out.length - 1 - imm.length));
       }
@@ -1227,16 +1274,19 @@ var name = (node, list) => {
   return nm;
 };
 var typedef = ([dfn], ctx) => {
-  let subkind = "subfinal", supertypes = [], compkind;
+  let subkind = "subfinal", supertypes = [], compkind, desc = [];
   if (dfn[0] === "sub") {
     subkind = dfn.shift(), dfn[0] === "final" && (subkind += dfn.shift());
     dfn = (supertypes = dfn).pop();
+    supertypes = supertypes.filter((n) => Array.isArray(n) && (n[0] === "descriptor" || n[0] === "describes") ? (desc.push(n), false) : true);
   }
   [compkind, ...dfn] = dfn;
   if (compkind === "func") dfn = paramres(dfn), ctx.type["$" + dfn.join(">")] ??= ctx.type.length;
   else if (compkind === "struct") dfn = fieldseq(dfn, "field");
   else if (compkind === "array") [dfn] = dfn;
-  return [compkind, dfn, subkind, supertypes];
+  const result = [compkind, dfn, subkind, supertypes];
+  if (desc.length) result.desc = desc;
+  return result;
 };
 var build = [
   // (@custom "name" placement? data) - custom section builder
@@ -1251,29 +1301,37 @@ var build = [
   // (func params result)
   // (array i8)
   // (struct ...fields)
-  ([kind, fields, subkind, supertypes, rec], ctx) => {
+  // (cont $ft) - stack switching (Phase 3)
+  (node, ctx) => {
+    const [kind, fields, subkind, supertypes, rec] = node;
     if (rec === true) return;
-    let details;
+    const descPfx = (node.desc ?? []).flatMap(([clause, ref]) => [clause === "descriptor" ? 77 : 76, ...uleb(id(ref, ctx.type))]);
+    const comptype = (k, f) => {
+      if (k === "func") return [DEFTYPE.func, ...vec(f[0].map((t) => reftype(t, ctx))), ...vec(f[1].map((t) => reftype(t, ctx)))];
+      if (k === "array") return [DEFTYPE.array, ...fieldtype(f, ctx)];
+      if (k === "struct") return [DEFTYPE.struct, ...vec(f.map((t) => fieldtype(t, ctx)))];
+      if (k === "cont") return [DEFTYPE.cont, ...uleb(id(f[0] ?? f, ctx.type))];
+      return [DEFTYPE[k]];
+    };
     if (rec) {
-      kind = "rec";
-      let [from, length] = rec, subtypes = Array.from({ length }, (_, i) => build[SECTION.type](ctx.type[from + i].slice(0, 4), ctx));
-      details = vec(subtypes);
+      let [from, length] = rec;
+      const subtypes = Array.from({ length }, (_, i) => {
+        const t = ctx.type[from + i], sub = t.slice(0, 4);
+        if (t.desc) sub.desc = t.desc;
+        return build[SECTION.type](sub, ctx);
+      });
+      return [DEFTYPE.rec, ...vec(subtypes)];
     } else if (subkind === "sub" || supertypes?.length) {
-      details = [...vec(supertypes.map((n) => id(n, ctx.type))), ...build[SECTION.type]([kind, fields], ctx)];
-      kind = subkind;
-    } else if (kind === "func") {
-      details = [...vec(fields[0].map((t) => reftype(t, ctx))), ...vec(fields[1].map((t) => reftype(t, ctx)))];
-    } else if (kind === "array") {
-      details = fieldtype(fields, ctx);
-    } else if (kind === "struct") {
-      details = vec(fields.map((t) => fieldtype(t, ctx)));
+      return [DEFTYPE[subkind], ...vec(supertypes.map((n) => id(n, ctx.type))), ...descPfx, ...comptype(kind, fields)];
     }
-    return [DEFTYPE[kind], ...details];
+    return [...descPfx, ...comptype(kind, fields)];
   },
   // (import "math" "add" (func|table|global|memory|tag dfn?))
   ([mod, field, [kind, ...dfn]], ctx) => {
-    let details;
+    let details, kindByte = KIND[kind];
     if (kind === "func") {
+      const isExact = dfn[0] === "exact" && dfn.shift();
+      if (isExact) kindByte = 32;
       let [[, typeidx]] = dfn;
       details = uleb(id(typeidx, ctx.type));
     } else if (kind === "tag") {
@@ -1286,7 +1344,7 @@ var build = [
     } else if (kind === "table") {
       details = [...reftype(dfn.pop(), ctx), ...limits(dfn)];
     } else err(`Unknown kind ${kind}`);
-    return [...vec(mod), ...vec(field), KIND[kind], ...details];
+    return [...vec(mod), ...vec(field), kindByte, ...details];
   },
   // (func $name? ...params result ...body)
   ([[, typeidx]], ctx) => uleb(id(typeidx, ctx.type)),
@@ -1400,6 +1458,7 @@ var build = [
   // (data (i32.const 0) "\aa" "\bb"?)
   // (data (memory ref) (offset (i32.const 0)) "\aa" "\bb"?)
   // (data (global.get $x) "\aa" "\bb"?)
+  // (data (i8 1 2 3) ...) numeric values (WAT numeric values, Phase 2)
   (inits, ctx) => {
     let offset, memidx = 0;
     if (inits[0]?.[0] === "memory") {
@@ -1422,7 +1481,7 @@ var build = [
           [1]
         )
       ),
-      ...vec(inits.flat())
+      ...vec(inits.flatMap((item) => numdata(item) ?? [...item]))
     ];
   },
   // datacount
@@ -1430,7 +1489,13 @@ var build = [
   // (tag $name? (type idx))
   ([[, typeidx]], ctx) => [0, ...uleb(id(typeidx, ctx.type))]
 ];
-var reftype = (t, ctx) => t[0] === "ref" ? t[1] == "null" ? TYPE[t[2]] ? [TYPE[t[2]]] : [TYPE.refnull, ...uleb(id(t[t.length - 1], ctx.type))] : [TYPE.ref, ...uleb(TYPE[t[t.length - 1]] || id(t[t.length - 1], ctx.type))] : (
+var reftype = (t, ctx) => t[0] === "ref" ? t[1] == "null" ? (
+  // (ref null (exact $T)) - exact nullable ref
+  Array.isArray(t[2]) && t[2][0] === "exact" ? [TYPE.refnull, 98, ...uleb(id(t[2][1], ctx.type))] : TYPE[t[2]] ? [TYPE[t[2]]] : [TYPE.refnull, ...uleb(id(t[t.length - 1], ctx.type))]
+) : (
+  // (ref (exact $T)) - exact non-null ref
+  Array.isArray(t[1]) && t[1][0] === "exact" ? [TYPE.ref, 98, ...uleb(id(t[1][1], ctx.type))] : [TYPE.ref, ...uleb(TYPE[t[t.length - 1]] || id(t[t.length - 1], ctx.type))]
+) : (
   // abbrs
   [TYPE[t] ?? err(`Unknown type ${t}`)]
 );
@@ -1478,7 +1543,7 @@ var IMM = {
   },
   ref_null: (n, c) => {
     let t = n.shift();
-    return TYPE[t] ? [TYPE[t]] : uleb(id(t, c.type));
+    return Array.isArray(t) && t[0] === "exact" ? [98, ...uleb(id(t[1], c.type))] : TYPE[t] ? [TYPE[t]] : uleb(id(t, c.type));
   },
   memarg: (n, c, op) => memargEnc(n, op, isIdx(n[0]) && !isMemParam(n[0]) ? id(n.shift(), c.memory) : 0),
   opt_memory: (n, c) => uleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
@@ -1487,8 +1552,8 @@ var IMM = {
     return ht.length > 1 ? ht.slice(1) : ht;
   },
   reftype2: (n, c) => {
-    let b = blockid(n.shift(), c.block), h1 = reftype(n.shift(), c), h2 = reftype(n.shift(), c);
-    return [(h2[0] !== TYPE.ref) << 1 | h1[0] !== TYPE.ref, ...uleb(b), h1.pop(), h2.pop()];
+    let b = blockid(n.shift(), c.block), h1 = reftype(n.shift(), c), h2 = reftype(n.shift(), c), ht = (h) => h.length > 1 ? h.slice(1) : h;
+    return [(h2[0] !== TYPE.ref) << 1 | h1[0] !== TYPE.ref, ...uleb(b), ...ht(h1), ...ht(h2)];
   },
   v128const: (n) => {
     let [t, num] = n.shift().split("x"), bits = +t.slice(1), stride = bits >>> 3;
@@ -1543,7 +1608,47 @@ var IMM = {
   typeidx_typeidx: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.type))],
   dataidx_memoryidx: (n, c) => [...uleb(id(n.shift(), c.data)), ...uleb(id(n.shift(), c.memory))],
   memoryidx_memoryidx: (n, c) => [...uleb(id(n.shift(), c.memory)), ...uleb(id(n.shift(), c.memory))],
-  tableidx_tableidx: (n, c) => [...uleb(id(n.shift(), c.table)), ...uleb(id(n.shift(), c.table))]
+  tableidx_tableidx: (n, c) => [...uleb(id(n.shift(), c.table)), ...uleb(id(n.shift(), c.table))],
+  // stack switching handlers (Phase 3)
+  cont_bind: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.type))],
+  switch_cont: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.tag))],
+  resume: (n, c) => {
+    const typeidx = uleb(id(n.shift(), c.type));
+    const handlers = [];
+    let cnt = 0;
+    while (n[0]?.[0] === "on") {
+      const [, tag, label] = n.shift();
+      if (label === "switch") handlers.push(1, ...uleb(id(tag, c.tag)));
+      else handlers.push(0, ...uleb(id(tag, c.tag)), ...uleb(blockid(label, c.block)));
+      cnt++;
+    }
+    return [...typeidx, ...uleb(cnt), ...handlers];
+  },
+  resume_throw: (n, c) => {
+    const typeidx = uleb(id(n.shift(), c.type));
+    const exnidx = uleb(id(n.shift(), c.tag));
+    const handlers = [];
+    let cnt = 0;
+    while (n[0]?.[0] === "on") {
+      const [, tag, label] = n.shift();
+      if (label === "switch") handlers.push(1, ...uleb(id(tag, c.tag)));
+      else handlers.push(0, ...uleb(id(tag, c.tag)), ...uleb(blockid(label, c.block)));
+      cnt++;
+    }
+    return [...typeidx, ...exnidx, ...uleb(cnt), ...handlers];
+  },
+  resume_throw_ref: (n, c) => {
+    const typeidx = uleb(id(n.shift(), c.type));
+    const handlers = [];
+    let cnt = 0;
+    while (n[0]?.[0] === "on") {
+      const [, tag, label] = n.shift();
+      if (label === "switch") handlers.push(1, ...uleb(id(tag, c.tag)));
+      else handlers.push(0, ...uleb(id(tag, c.tag)), ...uleb(blockid(label, c.block)));
+      cnt++;
+    }
+    return [...typeidx, ...uleb(cnt), ...handlers];
+  }
 };
 var HANDLER = {};
 (function populate(items, pre) {
@@ -1561,7 +1666,7 @@ var instr = (nodes, ctx) => {
       continue;
     }
     if (Array.isArray(op)) {
-      op.i != null && (err.i = op.i);
+      op.loc != null && (err.loc = op.loc);
       err(`Unknown instruction ${op[0]}`);
     }
     let [...bytes] = INSTR[op] || err(`Unknown instruction ${op}`);
@@ -1603,17 +1708,36 @@ var align = (op) => {
   let k = op[i] === "l" ? i + 4 : i + 5, m = op.slice(k).match(/(\d+)(x|_|$)/);
   return Math.log2(m ? m[2] === "x" ? 8 : m[1] / 8 : +group / 8);
 };
+var numdata = (item) => {
+  if (!Array.isArray(item)) return null;
+  const [t, ...vs] = item;
+  if (t !== "i8" && t !== "i16" && t !== "i32" && t !== "i64" && t !== "f32" && t !== "f64") return null;
+  const out = [], dv = new DataView(new ArrayBuffer(8));
+  for (const v of vs) {
+    if (t === "i8") out.push(i32.parse(v) & 255 + 256 & 255);
+    else if (t === "i16") dv.setInt16(0, i32.parse(v), true), out.push(...new Uint8Array(dv.buffer, 0, 2));
+    else if (t === "i32") dv.setInt32(0, i32.parse(v), true), out.push(...new Uint8Array(dv.buffer, 0, 4));
+    else if (t === "i64") dv.setBigInt64(0, BigInt(v), true), out.push(...new Uint8Array(dv.buffer, 0, 8));
+    else if (t === "f32") out.push(...f32(v));
+    else if (t === "f64") out.push(...f64(v));
+  }
+  return out;
+};
 var limits = (node) => {
   const is64 = node[0] === "i64" && node.shift();
   const shared = node[node.length - 1] === "shared" && node.pop();
+  const psIdx = node.findIndex((n) => Array.isArray(n) && n[0] === "pagesize");
+  let psLog2 = -1;
+  if (psIdx >= 0) psLog2 = Math.log2(+node.splice(psIdx, 1)[0][1]);
   const hasMax = !isNaN(parseInt(node[1]));
-  const flag = (is64 ? 4 : 0) | (shared ? 2 : 0) | (hasMax ? 1 : 0);
+  const flag = (psLog2 >= 0 ? 8 : 0) | (is64 ? 4 : 0) | (shared ? 2 : 0) | (hasMax ? 1 : 0);
   const parse = is64 ? (v) => {
     if (typeof v === "bigint") return v;
     const str2 = typeof v === "string" ? v.replaceAll("_", "") : String(v);
     return BigInt(str2);
   } : parseUint;
-  return hasMax ? [flag, ...uleb(parse(node.shift())), ...uleb(parse(node.shift()))] : [flag, ...uleb(parse(node.shift()))];
+  const ps = psLog2 >= 0 ? uleb(psLog2) : [];
+  return hasMax ? [flag, ...uleb(parse(node.shift())), ...uleb(parse(node.shift())), ...ps] : [flag, ...uleb(parse(node.shift())), ...ps];
 };
 var parseUint = (v, max = 4294967295) => {
   const n = typeof v === "string" && v[0] !== "+" ? i32.parse(v) : typeof v === "number" ? v : err(`Bad int ${v}`);
@@ -2687,7 +2811,8 @@ var treeshake = (ast) => {
     }
   }
   for (const start of starts) {
-    const ref = start[1];
+    let ref = start[1];
+    if (typeof ref === "string" && ref[0] !== "$") ref = +ref;
     if (funcs.has(ref)) funcs.get(ref).used = true;
   }
   let hasExports = exports.length > 0 || starts.length > 0;
@@ -3308,7 +3433,17 @@ var inline = (ast) => {
       }
     }
     if (params && !hasLocals && !hasExport && params.length <= 2 && body.length === 1) {
-      inlinable.set(name2, { body: body[0], params });
+      const paramNames = new Set(params.map((p) => p.name));
+      let mutatesParam = false;
+      walk2(body[0], (n) => {
+        if (!Array.isArray(n)) return;
+        if ((n[0] === "local.set" || n[0] === "local.tee") && paramNames.has(n[1])) {
+          mutatesParam = true;
+        }
+      });
+      if (!mutatesParam) {
+        inlinable.set(name2, { body: body[0], params });
+      }
     }
   }
   if (inlinable.size === 0) return result;