porffor 0.16.0-594397507 → 0.16.0-6572d1c74

package/compiler/codegen.js

@@ -1078,7 +1078,7 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     locals,
     localInd: allLocals.length,
     returns,
-    returnType: returnType ?? TYPES.number,
+    returnType,
     internal: true,
     index: currentFuncIndex++,
     table
@@ -1254,7 +1254,7 @@ const getNodeType = (scope, node) => {
       const func = funcs.find(x => x.name === name);
 
       if (func) {
-        if (func.returnType) return func.returnType;
+        if (func.returnType != null) return func.returnType;
       }
 
       if (builtinFuncs[name] && !builtinFuncs[name].typedReturns) return builtinFuncs[name].returnType ?? TYPES.number;
@@ -1270,15 +1270,7 @@ const getNodeType = (scope, node) => {
         const func = spl[spl.length - 1];
         const protoFuncs = Object.keys(prototypeFuncs).filter(x => x != TYPES.bytestring && prototypeFuncs[x][func] != null);
         if (protoFuncs.length === 1) {
-          if (protoFuncs[0].returnType) return protoFuncs[0].returnType;
-        }
-
-        if (protoFuncs.length > 0) {
-          if (scope.locals['#last_type']) return getLastType(scope);
-
-          // presume
-          // todo: warn here?
-          return TYPES.number;
+          if (protoFuncs[0].returnType != null) return protoFuncs[0].returnType;
         }
       }
 
@@ -1815,7 +1807,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       f64_store: { imms: 2, args: [ true, false ], returns: 0 },
 
       // value
-      i32_const: { imms: 1, args: [], returns: 1 },
+      i32_const: { imms: 1, args: [], returns: 0 },
     };
 
     const opName = name.slice('__Porffor_wasm_'.length);
@@ -1978,7 +1970,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   const func = funcs[idx - importedFuncs.length]; // idx === scope.index ? scope : funcs.find(x => x.index === idx);
   const userFunc = func && !func.internal;
   const typedParams = userFunc || builtinFuncs[name]?.typedParams;
-  const typedReturns = (func && func.returnType == null) || builtinFuncs[name]?.typedReturns;
+  const typedReturns = (userFunc && func.returnType == null) || builtinFuncs[name]?.typedReturns;
   const paramCount = func && (typedParams ? func.params.length / 2 : func.params.length);
 
   let args = decl.arguments;
@@ -2007,8 +1999,8 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     }
 
     if (valtypeBinary !== Valtype.i32 && (
-      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
-      (importedFuncs[name] && name.startsWith('profile'))
+      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32)
+      // (importedFuncs[name] && name.startsWith('profile'))
     )) {
       out.push(Opcodes.i32_to);
     }
@@ -2189,7 +2181,7 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
   if (Prefs.typeswitchUseBrtable)
     return brTable(type, bc, returns);
 
-  const tmp = localTmp(scope, '#typeswitch_tmp', Valtype.i32);
+  const tmp = localTmp(scope, '#typeswitch_tmp' + (Prefs.typeswitchUniqueTmp ? randId() : ''), Valtype.i32);
   const out = [
     ...type,
     [ Opcodes.local_set, tmp ],
@@ -2571,7 +2563,7 @@ const generateUnary = (scope, decl) => {
       // * -1
 
       if (decl.prefix && decl.argument.type === 'Literal' && typeof decl.argument.value === 'number') {
-        // if -<N>, just return that
+        // if -n, just return that as a const
         return number(-1 * decl.argument.value);
       }
 
@@ -2583,14 +2575,14 @@ const generateUnary = (scope, decl) => {
     case '!':
       const arg = decl.argument;
       if (arg.type === 'UnaryExpression' && arg.operator === '!') {
-        // !!x -> is x truthy
+        // opt: !!x -> is x truthy
         return truthy(scope, generate(scope, arg.argument), getNodeType(scope, arg.argument), false, false);
       }
+
       // !=
-      return falsy(scope, generate(scope, decl.argument), getNodeType(scope, decl.argument), false, false);
+      return falsy(scope, generate(scope, arg), getNodeType(scope, arg), false, false);
 
     case '~':
-      // todo: does not handle Infinity properly (should convert to 0) (but opt const converting saves us sometimes)
       return [
         ...generate(scope, decl.argument),
         Opcodes.i32_to,
@@ -3510,7 +3502,7 @@ const generateMember = (scope, decl, _global, _name) => {
     }
 
     if (builtinFuncs[name]) return withType(scope, number(builtinFuncs[name].typedParams ? (builtinFuncs[name].params.length / 2) : builtinFuncs[name].params.length), TYPES.number);
-    if (importedFuncs[name]) return withType(scope, number(importedFuncs[name].params), TYPES.number);
+    if (importedFuncs[name]) return withType(scope, number(importedFuncs[name].params.length ?? importedFuncs[name].params), TYPES.number);
     if (internalConstrs[name]) return withType(scope, number(internalConstrs[name].length ?? 0), TYPES.number);
 
     if (Prefs.fastLength) {
@@ -3979,19 +3971,8 @@ export default program => {
   data = [];
   currentFuncIndex = importedFuncs.length;
 
-  globalThis.valtype = 'f64';
-
-  const valtypeOpt = process.argv.find(x => x.startsWith('--valtype='));
-  if (valtypeOpt) valtype = valtypeOpt.split('=')[1];
-
-  globalThis.valtypeBinary = Valtype[valtype];
-
   const valtypeInd = ['i32', 'i64', 'f64'].indexOf(valtype);
 
-  globalThis.pageSize = PageSize;
-  const pageSizeOpt = process.argv.find(x => x.startsWith('--page-size='));
-  if (pageSizeOpt) pageSize = parseInt(pageSizeOpt.split('=')[1]) * 1024;
-
   // set generic opcodes for current valtype
   Opcodes.const = [ Opcodes.i32_const, Opcodes.i64_const, Opcodes.f64_const ][valtypeInd];
   Opcodes.eq = [ Opcodes.i32_eq, Opcodes.i64_eq, Opcodes.f64_eq ][valtypeInd];

package/compiler/cyclone.js

@@ -0,0 +1,535 @@
+// cyclone: wasm partial constant evaluator (it is fast and dangerous hence "cyclone")
+import { signedLEB128, ieee754_binary64, read_ieee754_binary64, read_signedLEB128 } from './encoding.js';
+import { Opcodes, Valtype } from './wasmSpec.js';
+
+const number = (n, valtype = valtypeBinary) => {
+  switch (valtype) {
+    case Valtype.i32: return [ Opcodes.i32_const, ...signedLEB128(n) ];
+    case Valtype.i64: return [ Opcodes.i64_const, ...signedLEB128(n) ];
+    case Valtype.f64: return [ Opcodes.f64_const, ...ieee754_binary64(n) ];
+  }
+};
+
+const f64ToI32Op = {
+  [Opcodes.f64_eq]: Opcodes.i32_eq,
+  [Opcodes.f64_ne]: Opcodes.i32_ne,
+  [Opcodes.f64_lt]: Opcodes.i32_lt_s,
+  [Opcodes.f64_le]: Opcodes.i32_le_s,
+  [Opcodes.f64_gt]: Opcodes.i32_gt_s,
+  [Opcodes.f64_ge]: Opcodes.i32_ge_s,
+  [Opcodes.f64_add]: Opcodes.i32_add,
+  [Opcodes.f64_sub]: Opcodes.i32_sub,
+  [Opcodes.f64_mul]: Opcodes.i32_mul,
+  [Opcodes.f64_div]: Opcodes.i32_div_s,
+};
+
+export default wasm => {
+  let stack = []; // """""stack"""""
+  for (let i = 0; i < wasm.length; i++) {
+    let op = wasm[i];
+    if (!op) continue;
+
+    // op = [ ...op.filter(x => x != null && x <= 0xff) ];
+    op = [ ...op ];
+    wasm[i] = op;
+
+    let opcode = op[0];
+    if (opcode === 0xfc) { // multibyte op
+      opcode = (opcode << 8) + op[1];
+    }
+
+    const push = val => {
+      stack.push({ val, op });
+    };
+
+    const pop = () => {
+      const popped = stack.pop();
+
+      // remove the op
+      wasm.splice(wasm.indexOf(popped.op), 1);
+      i--;
+
+      return popped.val;
+    };
+
+    const pop2 = () => [ pop(), pop() ];
+
+    const bool = v => v ? 1 : 0;
+
+    const replaceOp = newOp => {
+      op.splice(0, op.length, ...newOp);
+    };
+    const replaceVal = (val, valtype) => replaceOp(number(val, valtype));
+
+    const empty = () => {
+      stack = [];
+    };
+
+    switch (opcode) {
+      case Opcodes.i32_const: {
+        const n = read_signedLEB128(op.slice(1));
+        push(n);
+        break;
+      }
+      case Opcodes.f64_const: {
+        const n = read_ieee754_binary64(op.slice(1));
+        push(n);
+        break;
+      }
+
+      case Opcodes.i32_eqz: {
+        if (stack.length < 1) { empty(); break; };
+        const v = bool(pop() === 0);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_eq: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a === b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_ne: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a !== b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_lt_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a < b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_le_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a <= b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_gt_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a > b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_ge_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a >= b);
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+
+      case Opcodes.i32_add: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a + b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_sub: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a - b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_mul: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a * b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_div_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a / b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_rem_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a % b; // not rem but good enough
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+
+      case Opcodes.i32_and: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a & b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_or: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a | b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_xor: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a ^ b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_shl: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a << b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_shr_s: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a >> b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+      case Opcodes.i32_shr_u: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a >>> b;
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_eq: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a === b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_ne: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a !== b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_lt: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a < b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_le: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a <= b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_gt: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a > b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_ge: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = bool(a >= b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_abs: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.abs(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_neg: {
+        if (stack.length < 1) { empty(); break; };
+        const v = -pop();
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_ceil: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.ceil(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_floor: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.floor(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_trunc: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.trunc(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_nearest: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.round(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_sqrt: {
+        if (stack.length < 1) { empty(); break; };
+        const v = Math.sqrt(pop());
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_add: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a + b;
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_sub: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a - b;
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_mul: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a * b;
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_div: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a / b;
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_min: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = Math.min(a, b);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+      case Opcodes.f64_max: {
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = a + b;
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_copysign: { // ?
+        if (stack.length < 2) { empty(); break; };
+        const [ b, a ] = pop2();
+        const v = Math.abs(a) * (b > 0 ? 1 : -1);
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case Opcodes.f64_convert_i32_u:
+      case Opcodes.f64_convert_i32_s: {
+        if (stack.length < 1) { empty(); break; };
+        const v = pop();
+
+        replaceVal(v, Valtype.f64);
+        push(v);
+        break;
+      }
+
+      case 0xfc02: { // i32_trunc_sat_f64_s
+        if (stack.length < 1) { empty(); break; }
+        const v = pop();
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+
+      case 0xfc03: { // i32_trunc_sat_f64_u
+        if (stack.length < 1) { empty(); break; }
+        const v = pop();
+
+        replaceVal(v, Valtype.i32);
+        push(v);
+        break;
+      }
+
+      default: {
+        empty();
+        break;
+      }
+    }
+
+    // this does, eg:
+    // local.get 7 ;; $i (i32)
+    // f64.convert_i32_s
+    // f64.const 1
+    // f64.add
+    // i32.trunc_sat_f64_s <--
+    // local.set 7 ;; $i (i32)
+    // ->
+    // local.get 7 ;; $i (i32)
+    // i32.const 1
+    // i32.add
+    // local.set 7 ;; $i (i32)
+    if (
+      (opcode >= 0xa0 && opcode <= 0xa3) || // main f64 math op
+      (opcode >= 0x61 && opcode <= 0x66) // main f64 eq op
+    ) {
+      const o2 = wasm[i - 1][0];
+      if (o2 === Opcodes.f64_const) { // f64.const
+        const o3 = wasm[i - 2][0];
+        if (o3 === Opcodes.f64_convert_i32_s || o3 === Opcodes.f64_convert_i32_u) {
+          // remove now unneeded i32 -> f64 convert
+          wasm.splice(i - 2, 1);
+          i--;
+
+          // convert f64.const -> i32.const
+          const n = read_ieee754_binary64(wasm[i - 1].slice(1));
+          wasm.splice(i - 1, 1, number(n, Valtype.i32));
+
+          // convert math op from f64 to i32
+          wasm[i][0] = f64ToI32Op[wasm[i][0]];
+
+          const nextOp = wasm[i + 1];
+          if (nextOp && opcode >= 0xa0 && opcode <= 0xa3) {
+            if (nextOp[0] === 0xfc && (nextOp[1] === 0x02 || nextOp[1] === 0x03)) {
+              // remove optional unneeded f64 -> i32 convert after
+              wasm.splice(i + 1, 1);
+            } else {
+              // add now needed i32 -> f64 convert after
+              wasm.splice(i + 1, Opcodes.i32_trunc_sat_f64_s);
+            }
+          }
+        }
+      }
+    }
+
+    if ((opcode === 0xfc02 || opcode === 0xfc03) && i > 3) { // i32.trunc_sat_f64_s/u
+      const o2 = wasm[i - 1][0];
+      if (
+        (o2 >= 0xa0 && o2 <= 0xa3) || // main f64 math op
+        (o2 >= 0x61 && o2 <= 0x66) // main f64 eq op
+      ) {
+        const o3 = wasm[i - 2][0];
+        if (o3 === Opcodes.f64_const) { // f64.const
+          const o4 = wasm[i - 3][0];
+          if (o4 === Opcodes.f64_convert_i32_s || o4 === Opcodes.f64_convert_i32_u) {
+            // remove now unneeded i32 -> f64 convert
+            wasm.splice(i - 3, 1);
+            i--;
+          } else {
+            // add now needed f64 -> i32 convert prior
+            wasm.splice(i - 2, 0, Opcodes.i32_trunc_sat_f64_s);
+            i++;
+          }
+
+          // convert f64.const -> i32.const
+          const n = read_ieee754_binary64(wasm[i - 2].slice(1));
+          wasm.splice(i - 2, 1, number(n, Valtype.i32));
+
+          // convert math op from f64 to i32
+          wasm[i - 1][0] = f64ToI32Op[wasm[i - 1][0]];
+
+          // remove this now unneeded f64 -> i32 convert
+          wasm.splice(i, 1);
+        }
+      }
+    }
+  }
+};

package/compiler/decompile.js

@@ -4,6 +4,8 @@ import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from '.
 const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
 const invOpcodes = inv(Opcodes);
 const invValtype = inv(Valtype);
+globalThis.invOpcodes = invOpcodes;
+globalThis.invValtype = invValtype;
 
 export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = [], funcs = [], globals = {}, exceptions = []) => {
   const invLocals = inv(locals, x => x.idx);
@@ -91,7 +93,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       if (callFunc) out += ` ;; $${callFunc.name} ${makeSignature(callFunc.params, callFunc.returns)}`;
       if (globalThis.importFuncs && inst[1] < importFuncs.length) {
         const importFunc = importFuncs[inst[1]];
-        out += ` ;; import ${importFunc.name} ${makeSignature(new Array(importFunc.params).fill(valtypeBinary), new Array(importFunc.returns).fill(valtypeBinary),)}`;
+        out += ` ;; import ${importFunc.name} ${makeSignature(typeof importFunc.params === 'object' ? importFunc.params : new Array(importFunc.params).fill(valtypeBinary), new Array(importFunc.returns).fill(valtypeBinary),)}`;
       }
     }
 

package/compiler/generated_builtins.js

@@ -1748,7 +1748,7 @@ export const BuiltinFuncs = function() {
     localNames: ["iterable","iterable#type","out","type","forof_base_pointer","forof_length","forof_counter","x","x#type","#last_type","#typeswitch_tmp"],
   };
   this.__Set_prototype_union = {
-    wasm: (scope, {builtin,internalThrow,}) => [[32,2],[32,3],[16, builtin('__Porffor_rawType')],[68,0,0,0,0,0,0,52,64],[98],[4,64],...internalThrow(scope, 'TypeError', `Set.union requires 'Set'`),[11],[32,0],[65,20],[16, builtin('Set$constructor')],[33,4],[32,2],[252,3],[33,5],[65,0],[33,7],[32,5],[40,1,0],[33,6],[32,3],[33,11],[2,64],[32,11],[65,2],[70],[4,64,"TYPESWITCH|String"],[65,2],[33,9],[3,64],[65,0],[32,5],[47,0,4],[59,0,3],[68,0,0,0,0,0,0,240,191],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,2],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,16],[70],[4,64,"TYPESWITCH|Array"],[3,64],[32,5],[43,0,4],[32,5],[45,0,12],[33,9],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,9],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,18],[70],[4,64,"TYPESWITCH|ByteString"],[65,18],[33,9],[3,64],[65,0],[32,5],[32,7],[106],[45,0,4],[58,0,3],[68,0,0,0,0,0,0,240,191],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,20],[70],[4,64,"TYPESWITCH|Set"],[3,64],[32,5],[43,0,4],[32,5],[45,0,12],[33,9],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,9],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],...internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`),[11,"TYPESWITCH_end"],[32,4],[65,20],[15]],
+    wasm: (scope, {builtin,internalThrow,}) => [[32,2],[32,3],[16, builtin('__Porffor_rawType')],[68,0,0,0,0,0,0,52,64],[98],[4,64],...internalThrow(scope, 'TypeError', `Set.prototype.union's 'other' argument must be a Set`),[11],[32,0],[65,20],[16, builtin('Set$constructor')],[33,4],[32,2],[252,3],[33,5],[65,0],[33,7],[32,5],[40,1,0],[33,6],[32,3],[33,11],[2,64],[32,11],[65,2],[70],[4,64,"TYPESWITCH|String"],[65,2],[33,9],[3,64],[65,0],[32,5],[47,0,4],[59,0,3],[68,0,0,0,0,0,0,240,191],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,2],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,16],[70],[4,64,"TYPESWITCH|Array"],[3,64],[32,5],[43,0,4],[32,5],[45,0,12],[33,9],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,9],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,18],[70],[4,64,"TYPESWITCH|ByteString"],[65,18],[33,9],[3,64],[65,0],[32,5],[32,7],[106],[45,0,4],[58,0,3],[68,0,0,0,0,0,0,240,191],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],[32,11],[65,20],[70],[4,64,"TYPESWITCH|Set"],[3,64],[32,5],[43,0,4],[32,5],[45,0,12],[33,9],[33,8],[2,64],[32,4],[65,20],[32,8],[32,9],[16, builtin('__Set_prototype_add')],[26],[26],[32,5],[65,9],[106],[33,5],[32,7],[65,1],[106],[34,7],[32,6],[71],[13,1],[11],[11],[12,1],[11],...internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`),[11,"TYPESWITCH_end"],[32,4],[65,20],[15]],
     params: [124,127,124,127],
     typedParams: true,
     returns: [124,127],