porffor 0.41.5 → 0.41.7

package/compiler/codegen.js

@@ -49,19 +49,81 @@ const cacheAst = (decl, wasm) => {
 };
 
 const funcRef = func => {
-  // generate func
   func.generate?.();
 
   if (globalThis.precompile) return [
     [ Opcodes.const, 'funcref', func.name ]
   ];
 
+  const wrapperArgc = Prefs.indirectWrapperArgc ?? 6;
+  if (func.returns.length === 2 && countParams(func) < wrapperArgc && !func.wrapperFunc) {
+    const locals = {}, params = [];
+    for (let i = 0; i < wrapperArgc + (func.constr ? 2 : 0); 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 + (func.constr ? 2 : 0)) * 2;
+
+    const wasm = [];
+    for (let i = 0; i < func.params.length; i++) {
+      wasm.push(
+        [ Opcodes.local_get, i ],
+        ...(i % 2 === 0 && func.params[i] === Valtype.i32 ? [ Opcodes.i32_to ]: [])
+      );
+    }
+
+    wasm.push([ Opcodes.call, func.index ]);
+
+    if (func.returns[0] === Valtype.i32) {
+      const localIdx = localInd++;
+      locals[localIdx] = { idx: localIdx, type: Valtype.i32 };
+
+      wasm.push(
+        [ Opcodes.local_set, localIdx ],
+        Opcodes.i32_from,
+        [ Opcodes.local_get, localIdx ]
+      );
+    }
+
+    const name = '#indirect_' + func.name;
+    const wrapperFunc = {
+      name,
+      params,
+      locals, localInd,
+      returns: [ valtypeBinary, Valtype.i32 ],
+      wasm,
+      constr: func.constr,
+      internal: true,
+      index: currentFuncIndex++
+    };
+
+    funcs.push(wrapperFunc);
+    funcIndex[name] = wrapperFunc.index;
+
+    wrapperFunc.jsLength = countLength(func);
+    func.wrapperFunc = wrapperFunc;
+  }
+
   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 +307,7 @@ const internalThrow = (scope, constructor, message, expectsValue = Prefs.alwaysV
       ]
     }
   }),
-  ...(expectsValue ? number(UNDEFINED) : [])
+  ...(expectsValue ? number(UNDEFINED, typeof expectsValue === 'number' ? expectsValue : valtypeBinary) : [])
 ];
 
 const generateIdent = (scope, decl) => {
@@ -893,7 +955,7 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
 
 const asmFuncToAsm = (scope, func) => {
   return func(scope, {
-    TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage, internalThrow,
+    Valtype, Opcodes, TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage, internalThrow,
     getNodeType, generate, generateIdent,
     builtin: (n, offset = false) => {
       let idx = funcIndex[n] ?? importedFuncs[n];
@@ -910,6 +972,7 @@ const asmFuncToAsm = (scope, func) => {
 
       return idx;
     },
+    hasFunc: x => funcIndex[x] != null,
     funcRef: name => {
       if (funcIndex[name] == null && builtinFuncs[name]) {
         includeBuiltin(scope, name);
@@ -2166,102 +2229,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 ?? 6;
+      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
+          })
         ];
       }
 
@@ -2277,152 +2283,54 @@ 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]: () => [
-            ...out,
-
-            [ Opcodes.local_get, localTmp(scope, '#indirect_callee') ],
-            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.local_get, calleeLocal ],
+            Opcodes.i32_to_u,
+            ...number(48, Valtype.i32),
             [ Opcodes.i32_mul ],
-            ...number(4, Valtype.i32),
+            ...number(2, 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)
-          ],
 
-          ...(decl.optional ? {
-            [TYPES.undefined]: [
-              ...number(UNDEFINED),
-              ...setLastType(scope, TYPES.undefined)
-            ]
-          } : {}),
+            ...number(0b10, Valtype.i32),
+            [ Opcodes.i32_and ],
+            [ Opcodes.if, Valtype.f64 ],
+              ...forceDuoValtype(scope, newTargetWasm, Valtype.f64),
+              ...forceDuoValtype(scope, thisWasm, Valtype.f64),
+              ...out,
 
-          default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
-        })
+              [ Opcodes.local_get, calleeLocal ],
+              Opcodes.i32_to_u,
+              [ Opcodes.call_indirect, args.length + 2, 0 ],
+              ...setLastType(scope),
+            [ Opcodes.else ],
+              // throw if non-constructor called with new
+              ...(callAsNew ? [
+                ...internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, Valtype.f64)
+              ] : [
+                ...out,
+
+                [ Opcodes.local_get, calleeLocal ],
+                Opcodes.i32_to_u,
+                [ Opcodes.call_indirect, args.length, 0 ],
+                ...setLastType(scope)
+              ]),
+            [ Opcodes.end ]
+          ],
+
+          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 ] ] : [])
       ];
     }
 
@@ -3854,8 +3762,12 @@ const generateUpdate = (scope, decl, _global, _name, valueUnused = false) => {
 };
 
 const generateIf = (scope, decl) => {
-  const out = truthy(scope, generate(scope, decl.test), getNodeType(scope, decl.test), false, true);
+  if (globalThis.precompile && decl.test?.tag?.name === '__Porffor_comptime_flag') {
+    const flag = decl.test.quasi.quasis[0].value.raw;
+    return [ [ null, 'comptime_flag', flag, decl.consequent, '#', Prefs ] ];
+  }
 
+  const out = truthy(scope, generate(scope, decl.test), getNodeType(scope, decl.test), false, true);
 
   out.push([ Opcodes.if, Blocktype.void ]);
   depth.push('if');
@@ -5283,18 +5195,18 @@ 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('#indirect_')) name = name.slice(10);
+    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;
@@ -5414,17 +5326,40 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
 
     const known = knownType(scope, getNodeType(scope, decl.object));
     for (const x of prototypes) {
-      const type = TYPES[x.split('_prototype')[0].slice(2).toLowerCase()];
+      let type = TYPES[x.split('_prototype')[0].slice(2).toLowerCase()];
       if (type == null) continue;
 
       // do not __proto__ primitive hack for objects or functions
       if (type === TYPES.object || type === TYPES.function) continue;
 
+      // hack: do not support primitives for Object.prototype.isPrototypeOf
+      if (scope.name === '__Object_prototype_isPrototypeOf') {
+        switch (type) {
+          case TYPES.boolean:
+            type = TYPES.booleanobject;
+            break;
+
+          case TYPES.number:
+            type = TYPES.numberobject;
+            break;
+
+          case TYPES.string:
+            type = TYPES.stringobject;
+            break;
+
+          case TYPES.bytestring:
+            continue;
+        }
+      }
+
       const ident = {
         type: 'Identifier',
         name: x
       };
 
+      // hack: bytestrings should return string prototype
+      if (type === TYPES.bytestring) ident.name = '__String_prototype';
+
       bc[type] = () => [
         ...generate(scope, ident),
         ...setLastType(scope, getNodeType(scope, ident))
@@ -5926,6 +5861,10 @@ let objectHackers = [];
 const objectHack = node => {
   if (!node) return node;
 
+  // delete .end, .loc while here
+  delete node.end;
+  delete node.loc;
+
   if (node.type === 'MemberExpression') {
     const out = (() => {
       const abortOut = { ...node, object: objectHack(node.object) };
@@ -5950,7 +5889,7 @@ const objectHack = node => {
       if (objectName !== 'Object_prototype' && (node.property.name === 'propertyIsEnumerable' || node.property.name === 'hasOwnProperty' || node.property.name === 'isPrototypeOf')) return abortOut;
 
       const name = '__' + objectName + '_' + node.property.name;
-      if ((!hasFuncWithName(name) && !Object.hasOwn(builtinVars, name)) && (hasFuncWithName(objectName) || Object.hasOwn(builtinVars, objectName))) return abortOut;
+      if ((!hasFuncWithName(name) && !Object.hasOwn(builtinVars, name) && !isExistingProtoFunc(name) && !hasFuncWithName(name + '$get')) && (hasFuncWithName(objectName) || Object.hasOwn(builtinVars, objectName) || hasFuncWithName('__' + objectName) || Object.hasOwn(builtinVars, '__' + objectName))) return abortOut;
 
       if (Prefs.codeLog) log('codegen', `object hack! ${node.object.name}.${node.property.name} -> ${name}`);
 
@@ -6246,6 +6185,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();
 

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,23 +70,6 @@ const compile = async (file, _funcs) => {
     return acc;
   }, {});
 
-  const returnOverrides = {
-    __Porffor_object_get: [ 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) {
@@ -82,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 };
@@ -201,6 +201,10 @@ const precompile = async () => {
   const total = performance.now() - t;
   console.log(`\r${' '.repeat(100)}\r\u001b[90m${`[${total.toFixed(2)}ms]`.padEnd(12, ' ')}\u001b[0m\u001b[92mcompiled ${fileCount} files (${funcs.length} funcs)\u001b[0m \u001b[90m(${['parse', 'codegen', 'opt'].map(x => `${x}: ${((timing[x] / total) * 100).toFixed(0)}%`).join(', ')})\u001b[0m`);
 
+  const comptimeFlagChecks = {
+    hasFunc: x => `hasFunc('${x}')`
+  };
+
   return `// autogenerated by compiler/precompile.js
 import { number } from './embedding.js';
 
@@ -219,9 +223,19 @@ ${funcs.map(x => {
       .replace(/\["throw","(.*?)","(.*?)"\]/g, (_, constructor, message) => `...internalThrow(_,'${constructor}',\`${message}\`)`)
       .replace(/\["get object","(.*?)"\]/g, (_, objName) => `...generateIdent(_,{name:'${objName}'})`)
       .replace(/\[null,"typeswitch case start",\[(.*?)\]\],/g, (_, types) => `...t([${types}],()=>[`)
-      .replaceAll(',[null,"typeswitch case end"]', '])');
-
-    return `(_,{${str.includes('...t(') ? 't,' : ''}${`${str.includes('allocPage(') ? 'allocPage,' : ''}${str.includes('glbl(') ? 'glbl,' : ''}${str.includes('loc(') ? 'loc,' : ''}${str.includes('builtin(') ? 'builtin,' : ''}${str.includes('funcRef(') ? 'funcRef,' : ''}${str.includes('internalThrow(') ? 'internalThrow,' : ''}${str.includes('generateIdent(') ? 'generateIdent,' : ''}`.slice(0, -1)}})=>`.replace('_,{}', '') + str;
+      .replaceAll(',[null,"typeswitch case end"]', '])')
+      .replace(/\[null,"comptime_flag","(.*?)",(\{.*?\}),"#",(\{.*?\})\]/g, (_, flag, ast, prefs) => {
+        ast = JSON.parse(ast.replaceAll('\n', '\\n'));
+        ast = JSON.stringify(ast, (k, v) => {
+          if (k === 'loc' || k === 'start' || k === 'end') return undefined;
+          return v;
+        });
+
+        const [ id, extra ] = flag.split('.');
+        return `[null,()=>{if(${comptimeFlagChecks[id](extra)}){const r=()=>{valtype=Prefs.valtype??'f64';valtypeBinary=Valtype[valtype];const valtypeInd=['i32','i64','f64'].indexOf(valtype);Opcodes.i32_to=[[],[Opcodes.i32_wrap_i64],Opcodes.i32_trunc_sat_f64_s][valtypeInd];Opcodes.i32_to_u=[[],[Opcodes.i32_wrap_i64],Opcodes.i32_trunc_sat_f64_u][valtypeInd];Opcodes.i32_from=[[],[Opcodes.i64_extend_i32_s],[Opcodes.f64_convert_i32_s]][valtypeInd];Opcodes.i32_from_u=[[],[Opcodes.i64_extend_i32_u],[ Opcodes.f64_convert_i32_u]][valtypeInd]};const a=Prefs;Prefs=${prefs};r();const b=generate(_,${ast});Prefs=a;r();return b;}return []}]`;
+      });
+
+    return `(_,{${str.includes('hasFunc(') ? 'hasFunc,' : ''}${str.includes('Valtype[') ? 'Valtype,' : ''}${str.includes('Opcodes.') ? 'Opcodes,' : ''}${str.includes('...t(') ? 't,' : ''}${`${str.includes('allocPage(') ? 'allocPage,' : ''}${str.includes('glbl(') ? 'glbl,' : ''}${str.includes('loc(') ? 'loc,' : ''}${str.includes('builtin(') ? 'builtin,' : ''}${str.includes('funcRef(') ? 'funcRef,' : ''}${str.includes('internalThrow(') ? 'internalThrow,' : ''}${str.includes('generateIdent(') ? 'generateIdent,' : ''}${str.includes('generate(') ? 'generate,' : ''}`.slice(0, -1)}})=>`.replace('_,{}', '') + str;
   };
 
   const locals = Object.entries(x.locals).sort((a,b) => a[1].idx - b[1].idx)

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.5+1e2625ec1",
+  "version": "0.41.7+89be416c1",
   "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.5+1e2625ec1';
+globalThis.version = '0.41.7+89be416c1';
 
 // 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);
 }