porffor 0.41.6 → 0.42.0

package/compiler/codegen.js

@@ -48,20 +48,111 @@ const cacheAst = (decl, wasm) => {
   return wasm;
 };
 
+let indirectFuncs = [];
 const funcRef = func => {
-  // generate func
   func.generate?.();
 
   if (globalThis.precompile) return [
     [ Opcodes.const, 'funcref', func.name ]
   ];
 
+  const wrapperArgc = Prefs.indirectWrapperArgc ?? 8;
+  if (!func.wrapperFunc) {
+    const locals = {}, params = [];
+    for (let i = 0; i < wrapperArgc + 2; i++) {
+      params.push(valtypeBinary, Valtype.i32);
+      locals[i * 2] = { idx: i * 2, type: valtypeBinary };
+      locals[i * 2 + 1] = { idx: i * 2 + 1, type: Valtype.i32 };
+    }
+    let localInd = (wrapperArgc + 2) * 2;
+
+    const wasm = [];
+    const offset = func.constr ? 0 : 4;
+    for (let i = 0; i < func.params.length; i++) {
+      if (func.internal && func.name.includes('_prototype_') && i < 2) {
+        // special case: use real this for prototype internals
+        wasm.push(
+          [ Opcodes.local_get, 2 + i ],
+          ...(i % 2 === 0 && func.params[i] === Valtype.i32 ? [ Opcodes.i32_to ]: [])
+        );
+      } else {
+        wasm.push(
+          [ Opcodes.local_get, offset + (!func.internal || func.typedParams ? i : i * 2) ],
+          ...(i % 2 === 0 && func.params[i] === Valtype.i32 ? [ Opcodes.i32_to ]: [])
+        );
+      }
+    }
+
+    wasm.push([ Opcodes.call, func.index ]);
+
+    if (func.returns[0] === Valtype.i32) {
+      if (func.returns.length === 2) {
+        const localIdx = localInd++;
+        locals[localIdx] = { idx: localIdx, type: Valtype.i32 };
+
+        wasm.push(
+          [ Opcodes.local_set, localIdx ],
+          Opcodes.i32_from,
+          [ Opcodes.local_get, localIdx ]
+        );
+      } else {
+        wasm.push(Opcodes.i32_from);
+      }
+    }
+
+    if (func.returns.length === 1) {
+      // add built-in returnType if only returns a value
+      wasm.push(...number(func.returnType ?? TYPES.number, Valtype.i32));
+    }
+
+    const name = '#indirect_' + func.name;
+    const wrapperFunc = {
+      name,
+      params,
+      locals, localInd,
+      returns: [ valtypeBinary, Valtype.i32 ],
+      wasm,
+      constr: true,
+      internal: true,
+      indirect: true
+    };
+
+    indirectFuncs.push(wrapperFunc);
+
+    wrapperFunc.jsLength = countLength(func);
+    func.wrapperFunc = wrapperFunc;
+
+    if (!func.constr) {
+      // check not being constructed
+      wasm.unshift(
+        [ Opcodes.local_get, 0 ], // new.target value
+        Opcodes.i32_to_u,
+        [ Opcodes.if, Blocktype.void ], // if value is non-zero
+          ...internalThrow(wrapperFunc, 'TypeError', `${unhackName(func.name)} is not a constructor`), // throw type error
+        [ Opcodes.end ]
+      );
+    }
+  }
+
   return [
     [ Opcodes.const, func.index - importedFuncs.length ]
-    // [ Opcodes.const, func.index - importedFuncs.length, 'funcref' ]
   ];
 };
 
+const forceDuoValtype = (scope, wasm, forceValtype) => [
+  ...wasm,
+  ...(valtypeBinary === Valtype.i32 && forceValtype === Valtype.f64 ? [
+    [ Opcodes.local_set, localTmp(scope, '#swap', Valtype.i32) ],
+    [ Opcodes.f64_convert_i32_s ],
+    [ Opcodes.local_get, localTmp(scope, '#swap', Valtype.i32) ]
+  ] : []),
+  ...(valtypeBinary === Valtype.f64 && forceValtype === Valtype.i32 ? [
+    [ Opcodes.local_set, localTmp(scope, '#swap', Valtype.i32) ],
+    Opcodes.i32_trunc_sat_f64_s,
+    [ Opcodes.local_get, localTmp(scope, '#swap', Valtype.i32) ]
+  ] : [])
+];
+
 const generate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
   if (astCache.has(decl)) return astCache.get(decl);
 
@@ -245,7 +336,7 @@ const internalThrow = (scope, constructor, message, expectsValue = Prefs.alwaysV
       ]
     }
   }),
-  ...(expectsValue ? number(UNDEFINED) : [])
+  ...(expectsValue ? number(UNDEFINED, typeof expectsValue === 'number' ? expectsValue : valtypeBinary) : [])
 ];
 
 const generateIdent = (scope, decl) => {
@@ -2167,102 +2258,45 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     } else {
       if (!Prefs.indirectCalls) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
 
-      // todo: only works when function uses typedParams and typedReturns
-
-      const indirectMode = Prefs.indirectCallMode ?? 'vararg';
-      // options: vararg, strict
-      // - strict: simpler, smaller size usage, no func lut needed.
-      //   ONLY works when arg count of call == arg count of function being called
-      // - vararg: large size usage, cursed.
-      //   works when arg count of call != arg count of function being called*
-      //   * most of the time, some edgecases
-
       funcs.table = true;
       scope.table = true;
 
       let args = decl.arguments;
-      let locals = [];
-
-      if (indirectMode === 'vararg') {
-        const minArgc = Prefs.indirectCallMinArgc ?? 5;
-
-        if (args.length < minArgc) {
-          args = args.concat(new Array(minArgc - args.length).fill(DEFAULT_VALUE()));
-        }
+      const wrapperArgc = Prefs.indirectWrapperArgc ?? 8;
+      if (args.length < wrapperArgc) {
+        args = args.concat(new Array(wrapperArgc - args.length).fill(DEFAULT_VALUE()));
       }
 
       for (let i = 0; i < args.length; i++) {
         const arg = args[i];
-        out = out.concat(generate(scope, arg));
-        out = out.concat(getNodeType(scope, arg));
-
-        if (indirectMode === 'vararg') {
-          const typeLocal = localTmp(scope, `#indirect_arg${i}_type`, Valtype.i32);
-          const valLocal = localTmp(scope, `#indirect_arg${i}_val`);
-
-          locals.push([valLocal, typeLocal]);
-
-          out.push(
-            [ Opcodes.local_set, typeLocal ],
-            [ Opcodes.local_set, valLocal ]
-          );
-        }
+        out = out.concat(generate(scope, arg), valtypeBinary === Valtype.i32 && scope.locals[arg.name]?.type !== Valtype.f64 ? [ [ Opcodes.f64_convert_i32_s ] ] : [], getNodeType(scope, arg));
       }
 
-      if (indirectMode === 'strict') {
-        return [
-          ...generate(scope, decl.callee),
-          [ Opcodes.local_set, localTmp(scope, '#indirect_callee') ],
+      let knownThis = undefined, getCallee = undefined;
+      const calleeLocal = localTmp(scope, '#indirect_callee');
 
-          ...typeSwitch(scope, getNodeType(scope, decl.callee), {
-            [TYPES.function]: () => [
-              ...out,
+      // hack: this should be more thorough, Function.bind, etc
+      if (decl.callee.type === 'MemberExpression' && !decl._new) {
+        const thisLocal = localTmp(scope, '#indirect_caller');
+        const thisLocalType = localTmp(scope, '#indirect_caller#type', Valtype.i32);
 
-              [ Opcodes.local_get, localTmp(scope, '#indirect_callee') ],
-              ...generate(scope, decl.callee),
-              Opcodes.i32_to_u,
-              [ Opcodes.call_indirect, args.length, 0 ],
-              ...setLastType(scope)
-            ],
-            default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
-          })
+        knownThis = [
+          [ Opcodes.local_get, thisLocal ],
+          [ Opcodes.local_get, thisLocalType ]
         ];
-      }
-
-      // hi, I will now explain how vararg mode works:
-      // wasm's indirect_call instruction requires you know the func type at compile-time
-      // since we have varargs (variable argument count), we do not know it.
-      // we could just store args in memory and not use wasm func args,
-      // but that is slow (probably) and breaks js exports.
-      // instead, we generate every* possibility of argc and use different indirect_call
-      // ops for each one, with type depending on argc for that branch.
-      // then we load the argc for the wanted function from a memory lut,
-      // and call the branch with the matching argc we require.
-      // sorry, yes it is very cursed (and size inefficient), but indirect calls
-      // are kind of rare anyway (mostly callbacks) so I am not concerned atm.
-      // *for argc 0-3, in future (todo:) the max number should be
-      // dynamically changed to the max argc of any func in the js file.
-
-      const funcLocal = localTmp(scope, '#indirect_func', Valtype.i32);
-      const flags = localTmp(scope, '#indirect_flags', Valtype.i32);
-
-      let knownThis = undefined;
-      let getCalleeObj = undefined;
-      let initCalleeObj = undefined;
-
-      // hack: this should be more thorough, Function.bind, etc
-      if (decl.callee.type == 'MemberExpression' && !decl._new) {
-        const callee = localTmp(scope, '#indirect_callee_obj', Valtype.f64);
-        initCalleeObj = [
+        getCallee = [
           ...generate(scope, decl.callee.object),
-          [ Opcodes.local_set, callee ]
-        ];
-        getCalleeObj = [
-          [ Opcodes.local_get, callee ]
-        ];
-        knownThis = [
-          [ Opcodes.local_get, callee ],
-          ...getNodeType(scope, decl.callee.object)
+          [ Opcodes.local_set, thisLocal ],
+          ...getNodeType(scope, decl.callee.object),
+          [ Opcodes.local_set, thisLocalType ],
+
+          ...generate(scope, {
+            type: 'MemberExpression',
+            object: { type: 'Identifier', name: '#indirect_caller' },
+            property: decl.callee.property,
+            computed: decl.callee.computed,
+            optional: decl.callee.optional
+          })
         ];
       }
 
@@ -2278,152 +2312,29 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       }
 
       const newTargetWasm = decl._newTargetWasm ?? createNewTarget(scope, decl, [
-        [ Opcodes.local_get, funcLocal ],
-        Opcodes.i32_from_u
+        [ Opcodes.local_get, calleeLocal ]
       ], callAsNew);
-      const thisWasm = knownThis ?? createThisArg(scope, decl);
-
-      const gen = argc => {
-        const argsOut = [];
-        for (let i = 0; i < argc; i++) {
-          argsOut.push(
-            [ Opcodes.local_get, locals[i][0] ],
-            [ Opcodes.local_get, locals[i][1] ]
-          );
-        }
-
-        const checkFlag = (flag, pass, fail) => [
-          [ Opcodes.local_get, flags ],
-          ...number(flag, Valtype.i32),
-          [ Opcodes.i32_and ],
-          [ Opcodes.if, valtypeBinary ],
-          ...pass,
-          [ Opcodes.else ],
-          ...fail,
-          [ Opcodes.end ]
-        ];
-
-        // todo: i'm sure this could be made better somehow, probably only with #96?
-        return checkFlag(0b1,
-          // no type return
-          checkFlag(0b10, [
-            // no type return & constr
-            ...newTargetWasm,
-            ...thisWasm,
-            ...argsOut,
-            [ Opcodes.local_get, funcLocal ],
-            [ Opcodes.call_indirect, argc + 2, 0, 'no_type_return' ],
-          ], [
-            // no type return & not constr
-            ...argsOut,
-            [ Opcodes.local_get, funcLocal ],
-            [ Opcodes.call_indirect, argc, 0, 'no_type_return' ]
-          ]),
-
-          // type return
-          checkFlag(0b10, [
-            // type return & constr
-            ...newTargetWasm,
-            ...thisWasm,
-            ...argsOut,
-            [ Opcodes.local_get, funcLocal ],
-            [ Opcodes.call_indirect, argc + 2, 0 ],
-            ...setLastType(scope),
-          ], [
-            // type return
-            ...argsOut,
-            [ Opcodes.local_get, funcLocal ],
-            [ Opcodes.call_indirect, argc, 0 ],
-            ...setLastType(scope),
-          ])
-        );
-      };
-
-      const tableBc = {};
-      for (let i = 0; i <= args.length; i++) {
-        tableBc[i] = gen(i);
-      }
-
-      // todo/perf: check if we should use br_table here or just generate our own big if..elses
+      const thisWasm = decl._thisWasm ?? knownThis ?? createThisArg(scope, decl);
 
       return [
-        ...(getCalleeObj ? [
-          ...initCalleeObj,
-          ...generate(scope, callee, false, undefined, getCalleeObj)
-        ]: generate(scope, callee)),
-        [ Opcodes.local_set, localTmp(scope, '#indirect_callee') ],
+        ...(getCallee ? getCallee : generate(scope, callee)),
+        [ Opcodes.local_set, calleeLocal ],
 
         ...typeSwitch(scope, getNodeType(scope, callee), {
           [TYPES.function]: () => [
+            ...forceDuoValtype(scope, newTargetWasm, Valtype.f64),
+            ...forceDuoValtype(scope, thisWasm, Valtype.f64),
             ...out,
 
-            [ Opcodes.local_get, localTmp(scope, '#indirect_callee') ],
+            [ Opcodes.local_get, calleeLocal ],
             Opcodes.i32_to_u,
-            [ Opcodes.local_set, funcLocal ],
-
-            // get if func we are calling is a constructor or not
-            [ Opcodes.local_get, funcLocal ],
-            ...number(64, Valtype.i32),
-            [ Opcodes.i32_mul ],
-            ...number(4, Valtype.i32),
-            [ Opcodes.i32_add ],
-            [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut')), 'read func lut' ],
-            [ Opcodes.local_set, flags ],
-
-            // check if non-constructor was called with new, if so throw
-            ...(callAsNew ? [
-              [ Opcodes.local_get, flags ],
-              ...number(0b10, Valtype.i32),
-              [ Opcodes.i32_and ],
-              [ Opcodes.i32_eqz ],
-              [ Opcodes.if, Blocktype.void ],
-                ...internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`),
-              [ Opcodes.end ],
-            ] : []),
-
-            // [ Opcodes.local_get, funcLocal ],
-            // Opcodes.i32_from_u,
-            // [ Opcodes.call, 0 ],
-
-            // ...number(32),
-            // [ Opcodes.call, 1 ],
-
-            // [ Opcodes.local_get, funcLocal ],
-            // ...number(64, Valtype.i32),
-            // [ Opcodes.i32_mul ],
-            // [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut')), 'read func lut' ],
-            // Opcodes.i32_from_u,
-            // [ Opcodes.call, 0 ],
-
-            // [ Opcodes.local_get, funcLocal ],
-            // [ Opcodes.call, includeBuiltin(scope, '__Porffor_funcLut_name').index ],
-            // Opcodes.i32_from_u,
-            // ...number(TYPES.bytestring, Valtype.i32),
-            // [ Opcodes.call, includeBuiltin(scope, '__Porffor_printString').index ],
-            // [ Opcodes.drop ],
-            // [ Opcodes.drop ],
-
-            // ...number(10),
-            // [ Opcodes.call, 1 ],
-
-            ...brTable([
-              // get argc of func we are calling
-              [ Opcodes.local_get, funcLocal ],
-              ...number(64, Valtype.i32),
-              [ Opcodes.i32_mul ],
-              [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut')), 'read func lut' ]
-            ], tableBc, valtypeBinary)
+            [ Opcodes.call_indirect, args.length + 2, 0 ],
+            ...setLastType(scope)
           ],
 
-          ...(decl.optional ? {
-            [TYPES.undefined]: [
-              ...number(UNDEFINED),
-              ...setLastType(scope, TYPES.undefined)
-            ]
-          } : {}),
-
-          default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
-        })
+          default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, Valtype.f64)
+        }, Valtype.f64),
+        ...(valtypeBinary === Valtype.i32 && scope.returns[0] !== Valtype.f64 ? [ [ Opcodes.f64_convert_i32_s ] ] : [])
       ];
     }
 
@@ -2455,16 +2366,12 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     paramOffset += 4;
   }
 
-  if (func && !func.hasRestArgument && args.length < paramCount) {
+  if (func && args.length < paramCount) {
     // too little args, push undefineds
-    args = args.concat(new Array(paramCount - args.length).fill(DEFAULT_VALUE()));
+    args = args.concat(new Array(paramCount - (func.hasRestArgument ? 1 : 0) - args.length).fill(DEFAULT_VALUE()));
   }
 
   if (func && func.hasRestArgument) {
-    if (args.length < paramCount) {
-      args = args.concat(new Array(paramCount - 1 - args.length).fill(DEFAULT_VALUE()));
-    }
-
     const restArgs = args.slice(paramCount - 1);
     args = args.slice(0, paramCount - 1);
     args.push({
@@ -2478,13 +2385,18 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     args = args.slice(0, paramCount);
   }
 
-  if (func && func.throws) scope.throws = true;
-
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (Array.isArray(arg)) {
       // if wasm, just append it
       out = out.concat(arg);
+
+      if (valtypeBinary !== Valtype.i32 &&
+        (func && func.params[paramOffset + i * (typedParams ? 2 : 1)] === Valtype.i32)
+      ) {
+        out.push(...forceDuoValtype(scope, [], Valtype.i32));
+      }
+
       continue;
     }
 
@@ -3755,8 +3667,11 @@ const generateUnary = (scope, decl) => {
     case 'delete': {
       if (decl.argument.type === 'MemberExpression') {
         const object = decl.argument.object;
-        const property = getProperty(decl.argument);
 
+        // disallow `delete super.*`
+        if (object.type === 'Super') return internalThrow(scope, 'ReferenceError', 'Cannot delete super property', true);
+
+        const property = getProperty(decl.argument);
         if (property.value === 'length' || property.value === 'name') scope.noFastFuncMembers = true;
 
         return [
@@ -4690,8 +4605,6 @@ const generateLabel = (scope, decl) => {
 };
 
 const generateThrow = (scope, decl) => {
-  scope.throws = true;
-
   let exceptionMode = Prefs.exceptionMode ?? 'stack';
   if (globalThis.precompile) exceptionMode = decl.argument.callee != null ? 'lut' : 'stack';
 
@@ -5149,11 +5062,7 @@ const toPropertyKey = (scope, wasm, type, computed = false, i32Conv = false) =>
   ...wasm,
   ...type,
   [ Opcodes.call, includeBuiltin(scope, '__ecma262_ToPropertyKey').index ],
-  ...(i32Conv ? [
-    [ Opcodes.local_set, localTmp(scope, '#swap', Valtype.i32) ],
-    Opcodes.i32_to_u,
-    [ Opcodes.local_get, localTmp(scope, '#swap', Valtype.i32) ]
-  ] : [])
+  ...(i32Conv ? forceDuoValtype(scope, [], Valtype.i32) : [])
 ] : [
   ...wasm,
   ...(i32Conv ? [ Opcodes.i32_to_u ] : []),
@@ -5288,18 +5197,17 @@ const countLength = (func, name = undefined) => {
 
 const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) => {
   let final = [], finalEnd, extraBC = {};
-  const name = decl.object.name;
+  let name = decl.object.name;
 
   // todo: handle globalThis.foo
 
   // hack: .name
   if (decl.property.name === 'name' && hasFuncWithName(name) && !scope.noFastFuncMembers) {
-    let nameProp = name;
-
     // eg: __String_prototype_toLowerCase -> toLowerCase
-    if (nameProp.startsWith('__')) nameProp = nameProp.split('_').pop();
+    if (name.startsWith('__')) name = name.split('_').pop();
+    if (name.startsWith('#')) name = '';
 
-    return withType(scope, makeString(scope, nameProp, _global, _name, true), TYPES.bytestring);
+    return withType(scope, makeString(scope, name, _global, _name, true), TYPES.bytestring);
   }
 
   const object = decl.object;
@@ -5713,16 +5621,7 @@ const generateClass = (scope, decl) => {
     type: 'Identifier',
     name
   };
-  const proto = {
-    type: 'MemberExpression',
-    object: root,
-    property: {
-      type: 'Identifier',
-      name: 'prototype'
-    },
-    computed: false,
-    optional: false
-  };
+  const proto = getObjProp(root, 'prototype');
 
   const [ func, out ] = generateFunc(scope, {
     ...(body.find(x => x.kind === 'constructor')?.value ?? {
@@ -5749,7 +5648,7 @@ const generateClass = (scope, decl) => {
       // Bar.__proto__ = Foo
       // Bar.prototype.__proto__ = Foo.prototype
       ...generate(scope, setObjProp(root, '__proto__', decl.superClass)),
-      ...generate(scope, setObjProp(getObjProp(root, 'prototype'), '__proto__', getObjProp(decl.superClass, 'prototype')))
+      ...generate(scope, setObjProp(proto, '__proto__', getObjProp(decl.superClass, 'prototype')))
     );
   }
 
@@ -6278,6 +6177,18 @@ const generateFunc = (scope, decl) => {
   func.params = Object.values(func.locals).map(x => x.type);
   func.jsLength = jsLength;
 
+  if (globalThis.valtypeOverrides) {
+    if (globalThis.valtypeOverrides.returns[name]) func.returns = globalThis.valtypeOverrides.returns[name];
+    if (globalThis.valtypeOverrides.params[name]) {
+      func.params = globalThis.valtypeOverrides.params[name];
+
+      const localsVals = Object.values(func.locals);
+      for (let i = 0; i < func.params.length; i++) {
+        localsVals[i].type = func.params[i];
+      }
+    }
+  }
+
   // force generate for main
   if (name === 'main') func.generate();
 
@@ -6420,7 +6331,7 @@ export default program => {
   };
   tags = [];
   exceptions = [];
-  funcs = [];
+  funcs = []; indirectFuncs = [];
   funcIndex = {};
   depth = [];
   pages = new Map();
@@ -6475,6 +6386,7 @@ export default program => {
   // todo: these should just be deleted once able
   for (let i = 0; i < funcs.length; i++) {
     const f = funcs[i];
+
     if (f.wasm) {
       // run callbacks
       const wasm = f.wasm;
@@ -6531,9 +6443,15 @@ export default program => {
   //   }
   // }
 
-  delete globals['#ind'];
+  // add indirect funcs to end of funcs
+  for (let i = 0; i < indirectFuncs.length; i++) {
+    const f = indirectFuncs[i];
+    f.index = currentFuncIndex++;
+  }
+
+  funcs.push(...indirectFuncs);
 
-  // console.log([...usedTypes].map(x => TYPE_NAMES[x]));
+  delete globals['#ind'];
 
   return { funcs, globals, tags, exceptions, pages, data };
 };

package/compiler/precompile.js

@@ -13,6 +13,26 @@ const __dirname = fileURLToPath(new URL('.', import.meta.url));
 globalThis.precompileCompilerPath = __dirname;
 globalThis.precompile = true;
 
+globalThis.valtypeOverrides = {
+  returns: {
+    __Porffor_object_get: [ Valtype.f64, Valtype.i32 ],
+    __Porffor_object_getExplicit: [ Valtype.f64, Valtype.i32 ],
+    __Porffor_object_readValue: [ Valtype.f64, Valtype.i32 ],
+    __Porffor_object_set: [ Valtype.f64, Valtype.i32 ],
+    __Porffor_object_setStrict: [ Valtype.f64, Valtype.i32 ],
+    __Porffor_object_packAccessor: [ Valtype.f64, Valtype.i32 ]
+  },
+  params: {
+    __Porffor_object_set: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
+    __Porffor_object_setStrict: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
+    __Porffor_object_expr_init: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
+    __Porffor_object_expr_initWithFlags: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32, Valtype.i32, Valtype.i32 ],
+    __Porffor_object_class_value: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
+    __Porffor_object_class_method: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
+    __Porffor_object_define: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32, Valtype.i32, Valtype.i32 ],
+  }
+};
+
 const argv = process.argv.slice();
 
 const timing = {};
@@ -50,25 +70,6 @@ const compile = async (file, _funcs) => {
     return acc;
   }, {});
 
-  const returnOverrides = {
-    __Porffor_object_get: [ Valtype.f64, Valtype.i32 ],
-    __Porffor_object_getExplicit: [ Valtype.f64, Valtype.i32 ],
-    __Porffor_object_readValue: [ Valtype.f64, Valtype.i32 ],
-    __Porffor_object_set: [ Valtype.f64, Valtype.i32 ],
-    __Porffor_object_setStrict: [ Valtype.f64, Valtype.i32 ],
-    __Porffor_object_packAccessor: [ Valtype.f64, Valtype.i32 ]
-  };
-
-  const paramOverrides = {
-    __Porffor_object_set: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
-    __Porffor_object_setStrict: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
-    __Porffor_object_expr_init: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
-    __Porffor_object_expr_initWithFlags: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32, Valtype.i32, Valtype.i32 ],
-    __Porffor_object_class_value: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
-    __Porffor_object_class_method: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
-    __Porffor_object_define: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32, Valtype.i32, Valtype.i32 ],
-  };
-
   const main = funcs.find(x => x.name === 'main');
   const exports = funcs.filter(x => x.export && x.name !== 'main');
   for (const x of exports) {
@@ -84,9 +85,6 @@ const compile = async (file, _funcs) => {
       }).filter(x => x);
     }
 
-    if (returnOverrides[x.name]) x.returns = returnOverrides[x.name];
-    if (paramOverrides[x.name]) x.params = paramOverrides[x.name];
-
     const rewriteWasm = (x, wasm, rewriteLocals = false) => {
       const locals = Object.keys(x.locals).reduce((acc, y) => {
         acc[x.locals[y].idx] = { ...x.locals[y], name: y };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.41.6+eb38ba00c",
+  "version": "0.42.0+93da2c806",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.41.6+eb38ba00c';
+globalThis.version = '0.42.0+93da2c806';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -167,7 +167,7 @@ try {
   }
 } catch (e) {
   let out = e;
-  if (!process.argv.includes('-d') && Object.getPrototypeOf(e).message != null) out = `${e.constructor.name}${e.message != null ? `: ${e.message}` : ''}`;
+  if (!process.argv.includes('-d') && Object.getPrototypeOf(e).message != null) out = `${e.name}${e.message != null ? `: ${e.message}` : ''}`;
   console.error(out);
 }