porffor 0.55.17 → 0.55.19

package/compiler/codegen.js

@@ -136,7 +136,12 @@ const funcRef = func => {
       }
     }
 
-    if (func.returns.length === 1) {
+    if (func.returns.length === 0) {
+      // add to stack if returns nothing
+      wasm.push(number(UNDEFINED));
+    }
+
+    if (func.returns.length < 2) {
       // add built-in returnType if only returns a value
       wasm.push(number(func.returnType ?? TYPES.number, Valtype.i32));
     }
@@ -353,6 +358,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
       return cacheAst(decl, [ number(UNDEFINED) ]);
 
+    case 'TSAsExpression':
+      return cacheAst(decl, generate(scope, decl.expression));
+
     default:
       // ignore typescript nodes
       if (decl.type.startsWith('TS') ||
@@ -497,7 +505,7 @@ const lookup = (scope, name, failEarly = false) => {
 
     if (failEarly) return null;
 
-    return [ [ null, () => hoistLookup(scope, name), 1 ] ];
+    return [ [ null, () => hoistLookup(scope, name) ] ];
   }
 
   return [
@@ -539,12 +547,10 @@ const generateYield = (scope, decl) => {
     ...getNodeType(scope, arg),
 
     [ Opcodes.call, includeBuiltin(scope, scope.async ? '__Porffor_AsyncGenerator_yield' : '__Porffor_Generator_yield').index ],
-    [ Opcodes.drop ],
-    [ Opcodes.drop ],
 
     // return generator
     [ Opcodes.local_get, scope.locals['#generator_out'].idx ],
-    number(scope.async ? TYPES.__porffor_asyncgenerator : TYPES.__porffor_generator, Valtype.i32),
+    ...(scope.returnType != null ? [] : [ number(scope.async ? TYPES.__porffor_asyncgenerator : TYPES.__porffor_generator, Valtype.i32) ]),
     [ Opcodes.return ],
 
     // use undefined as yield expression value
@@ -565,8 +571,9 @@ const generateReturn = (scope, decl) => {
       ...generate(scope, arg),
       ...getNodeType(scope, arg),
 
+      // return generator
       [ Opcodes.call, includeBuiltin(scope, scope.async ? '__Porffor_AsyncGenerator_return' : '__Porffor_Generator_return').index ],
-      // returns generator
+      ...(scope.returnType != null ? [] : [ number(scope.async ? TYPES.__porffor_asyncgenerator : TYPES.__porffor_generator, Valtype.i32) ]),
       [ Opcodes.return ]
     ];
   }
@@ -581,16 +588,18 @@ const generateReturn = (scope, decl) => {
       number(TYPES.promise, Valtype.i32),
 
       [ Opcodes.call, includeBuiltin(scope, '__Porffor_promise_resolve').index ],
-      [ Opcodes.drop ],
-      [ Opcodes.drop ],
 
       // return promise
       [ Opcodes.local_get, scope.locals['#async_out_promise'].idx ],
-      number(TYPES.promise, Valtype.i32),
+      ...(scope.returnType != null ? [] : [ number(TYPES.promise, Valtype.i32) ]),
       [ Opcodes.return ]
     ];
   }
 
+  if (scope.returns.length === 0) return [
+    [ Opcodes.return ]
+  ];
+
   if (
     scope.constr && // only do this in constructors
     !globalThis.precompile // skip in precompiled built-ins, we should not require this and handle it ourselves
@@ -650,7 +659,7 @@ const generateReturn = (scope, decl) => {
       ]),
 
       [ Opcodes.local_get, localTmp(scope, '#return') ],
-      [ Opcodes.local_get, localTmp(scope, '#return#type', Valtype.i32) ],
+      ...(scope.returnType != null ? [] : [ [ Opcodes.local_get, localTmp(scope, '#return#type', Valtype.i32) ] ]),
       [ Opcodes.return ]
     ];
   }
@@ -757,8 +766,7 @@ const compareStrings = (scope, left, right, leftType, rightType, noConv = false)
     Opcodes.i32_to_u,
     ...rightType,
 
-    [ Opcodes.call, includeBuiltin(scope, '__Porffor_strcmp').index ],
-    [ Opcodes.drop ]
+    [ Opcodes.call, includeBuiltin(scope, '__Porffor_strcmp').index ]
   ];
 
   return [
@@ -771,7 +779,6 @@ const compareStrings = (scope, left, right, leftType, rightType, noConv = false)
     ...rightType,
 
     [ Opcodes.call, includeBuiltin(scope, '__Porffor_compareStrings').index ],
-    [ Opcodes.drop ],
 
     // convert valtype result to i32 as i32 output expected
     Opcodes.i32_trunc_sat_f64_u
@@ -997,6 +1004,18 @@ const performOp = (scope, op, left, right, leftType, rightType) => {
     );
   }
 
+  if (!eqOp && (knownLeft === TYPES.bigint || knownRight === TYPES.bigint) && !(knownLeft === TYPES.bigint && knownRight === TYPES.bigint)) {
+    const unknownType = knownLeft === TYPES.bigint ? rightType : leftType;
+    startOut.push(
+      ...unknownType,
+      number(TYPES.bigint, Valtype.i32),
+      [ Opcodes.i32_ne ],
+      [ Opcodes.if, Blocktype.void ],
+        ...internalThrow(scope, 'TypeError', 'Cannot mix BigInts and non-BigInts in numeric expressions'),
+      [ Opcodes.end ]
+    );
+  }
+
   // todo: if equality op and an operand is undefined, return false
   // todo: niche null hell with 0
 
@@ -1211,7 +1230,7 @@ const generateBinaryExp = (scope, decl) => {
 
 const asmFuncToAsm = (scope, func) => {
   return func(scope, {
-    Valtype, Opcodes, TYPES, TYPE_NAMES, typeSwitch, makeString, internalThrow,
+    Valtype, Opcodes, TYPES, TYPE_NAMES, usedTypes, typeSwitch, makeString, internalThrow,
     getNodeType, generate, generateIdent,
     builtin: (n, offset = false) => {
       let idx = funcIndex[n] ?? importedFuncs[n];
@@ -1282,7 +1301,7 @@ const asmFuncToAsm = (scope, func) => {
         return [ [ null, () => {
           if (types.some(x => usedTypes.has(x))) return wasm();
           return [];
-        }, 0 ] ];
+        } ] ];
       }
     },
     i32ify: wasm => {
@@ -1432,7 +1451,11 @@ const setInferred = (scope, name, type, global = false) => {
 };
 
 const getType = (scope, name, failEarly = false) => {
-  const fallback = failEarly ? [ number(TYPES.undefined, Valtype.i32) ] : [ [ null, () => hoistLookupType(scope, name), 1 ] ];
+  const fallback = failEarly ? [
+    number(TYPES.undefined, Valtype.i32)
+  ] : [
+    [ null, () => hoistLookupType(scope, name) ]
+  ];
 
   if (Object.hasOwn(builtinVars, name)) return [ number(builtinVars[name].type ?? TYPES.number, Valtype.i32) ];
 
@@ -1527,6 +1550,11 @@ const getNodeType = (scope, node) => {
   let guess = null;
   const ret = (() => {
     if (node._type) return node._type;
+
+    if (node.type === 'TSAsExpression') {
+      return extractTypeAnnotation(node).type;
+    }
+
     if (node.type === 'Literal') {
       if (node.regex) return TYPES.regexp;
 
@@ -1549,7 +1577,7 @@ const getNodeType = (scope, node) => {
     }
 
     if (node.type === 'CallExpression' || node.type === 'NewExpression') {
-      const name = node.callee.name;
+      let name = node.callee.name;
 
       // hack: special primitive object types
       if (node.type === 'NewExpression') {
@@ -1558,8 +1586,13 @@ const getNodeType = (scope, node) => {
         if (name === 'String') return TYPES.stringobject;
       }
 
+      // hack: try reading from member if call
+      if (name == null && node.callee.type === 'MemberExpression' && node.callee.property.name === 'call') {
+        name = node.callee.object.name;
+      }
+
       if (name == null) {
-        // iife
+        // unknown name
         return getLastType(scope);
       }
 
@@ -1568,7 +1601,7 @@ const getNodeType = (scope, node) => {
         if (func.returnType != null) return func.returnType;
       }
 
-      if (Object.hasOwn(builtinFuncs, name) && !builtinFuncs[name].typedReturns) return builtinFuncs[name].returnType ?? TYPES.number;
+      if (Object.hasOwn(builtinFuncs, name) && builtinFuncs[name].returnType != null) return builtinFuncs[name].returnType;
       if (Object.hasOwn(internalConstrs, name) && internalConstrs[name].type != null) return internalConstrs[name].type;
 
       // check if this is a prototype function
@@ -1619,13 +1652,15 @@ const getNodeType = (scope, node) => {
 
     if (node.type === 'BinaryExpression') {
       if (['==', '===', '!=', '!==', '>', '>=', '<', '<=', 'instanceof', 'in'].includes(node.operator)) return TYPES.boolean;
-      if (node.operator !== '+') return TYPES.number;
 
       const leftType = getNodeType(scope, node.left);
       const rightType = getNodeType(scope, node.right);
       const knownLeft = knownTypeWithGuess(scope, leftType);
       const knownRight = knownTypeWithGuess(scope, rightType);
 
+      if (knownLeft === TYPES.bigint || knownRight === TYPES.bigint) return TYPES.bigint;
+      if (node.operator !== '+') return TYPES.number;
+
       if ((knownLeft != null || knownRight != null) && !(
         (knownLeft === TYPES.string || knownRight === TYPES.string) ||
         (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring) ||
@@ -1650,6 +1685,11 @@ const getNodeType = (scope, node) => {
       if (node.operator === 'delete') return TYPES.boolean;
       if (node.operator === 'typeof') return TYPES.bytestring;
 
+      // todo: proper bigint support
+      const type = getNodeType(scope, node.argument);
+      const known = knownType(scope, type);
+      if (known === TYPES.bigint) return TYPES.bigint;
+
       return TYPES.number;
     }
 
@@ -1756,6 +1796,29 @@ const generateLiteral = (scope, decl, global, name) => {
     case 'string':
       return makeString(scope, decl.value);
 
+    case 'bigint':
+      let n = decl.value;
+
+      // inline if small enough
+      if ((n < 0 ? -n : n) < 0x8000000000000n) {
+        return [ number(Number(n)) ];
+      }
+
+      // todo/opt: calculate and statically store digits
+      return generate(scope, {
+        type: 'CallExpression',
+        callee: {
+          type: 'Identifier',
+          name: '__Porffor_bigint_fromString'
+        },
+        arguments: [
+          {
+            type: 'Literal',
+            value: decl.value.toString()
+          }
+        ]
+      });
+
     default:
       return todo(scope, `cannot generate literal of type ${typeof decl.value}`, true);
   }
@@ -1816,14 +1879,6 @@ const ArrayUtil = {
   ]
 };
 
-const getLastInst = wasm => {
-  for (let i = wasm.length - 1; i >= 0; i--) {
-    if (wasm[i]?.[0] != null) return wasm[i];
-  }
-
-  return null;
-};
-
 const createNewTarget = (scope, decl, idx = 0, force = false) => {
   if (decl._new || force) {
     return [
@@ -1971,8 +2026,6 @@ const createThisArg = (scope, decl) => {
       number(TYPES.number, Valtype.i32),
 
       [ Opcodes.call, includeBuiltin(scope, '__Porffor_object_expr_initWithFlags').index ],
-      [ Opcodes.drop ],
-      [ Opcodes.drop ],
 
       [ Opcodes.local_get, tmp ],
       number(TYPES.object, Valtype.i32)
@@ -2083,14 +2136,15 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   if (name === 'Function') {
-    const known = knownValue(scope, decl.arguments[0]);
-    if (known !== unknownValue) {
-      // new Function('with known/literal string')
-      const code = String(known);
+    const knowns = decl.arguments.map(x => knownValue(scope, x));
+    if (knowns.every(x => x !== unknownValue)) {
+      // new Function('with known/literal strings')
+      const code = String(knowns[knowns.length - 1]);
+      const args = knowns.slice(0, -1).map(x => String(x));
 
       let parsed;
       try {
-        parsed = objectHack(parse(`(function(){${code}})`));
+        parsed = objectHack(parse(`(function(${args.join(',')}){${code}})`));
       } catch (e) {
         if (e.name === 'SyntaxError') {
           // throw syntax errors of evals at runtime instead
@@ -2609,7 +2663,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
   const userFunc = func && !func.internal;
   const typedParams = userFunc || func?.typedParams;
-  const typedReturns = (userFunc && func.returnType == null) || builtinFuncs[name]?.typedReturns;
+  const typedReturns = func && func.returnType == null;
   let paramCount = countParams(func, name);
 
   let paramOffset = 0;
@@ -2709,17 +2763,19 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     // );
   } else out.push(...setLastType(scope));
 
-  if (builtinFuncs[name] && builtinFuncs[name].returns?.[0] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
-    out.push(Opcodes.i32_from);
+  if (
+    func?.returns?.length === 0 ||
+    (idx === importedFuncs[name] && importedFuncs[importedFuncs[name]]?.returns === 0)
+  ) {
+    out.push(number(UNDEFINED));
   }
 
-  if (builtinFuncs[name] && builtinFuncs[name].returns?.[0] === Valtype.f64 && valtypeBinary === Valtype.i32 && !globalThis.noi32F64CallConv) {
-    out.push(Opcodes.i32_trunc_sat_f64_s);
+  if (func?.returns?.[0] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
+    out.push(Opcodes.i32_from);
   }
 
-  if ((builtinFuncs[name] && builtinFuncs[name].returns?.length === 0) ||
-      (idx === importedFuncs[name] && importedFuncs[importedFuncs[name]]?.returns === 0)) {
-    out.push(number(UNDEFINED));
+  if (func?.returns?.[0] === Valtype.f64 && valtypeBinary === Valtype.i32 && !globalThis.noi32F64CallConv) {
+    out.push(Opcodes.i32_trunc_sat_f64_s);
   }
 
   return out;
@@ -2756,7 +2812,7 @@ const generateThis = (scope, decl) => {
           [ Opcodes.local_set, scope.locals['#this#type'].idx ],
         [ Opcodes.end ]
       ];
-    }, 0 ],
+    } ],
 
     [ Opcodes.local_get, scope.locals['#this'].idx ]
   ];
@@ -3038,7 +3094,7 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary, fallthrough = fals
             depth = oldDepth;
           }
           return out;
-        }, 0 ]);
+        } ]);
       }
     }
   }
@@ -3143,6 +3199,7 @@ const extractTypeAnnotation = decl => {
     type = a.typeName.name;
   } else if (a.type.endsWith('Keyword')) {
     type = a.type.slice(2, -7).toLowerCase();
+    if (type === 'void') type = 'undefined';
   } else if (a.type === 'TSArrayType') {
     type = 'array';
     elementType = extractTypeAnnotation(a.elementType).type;
@@ -4060,6 +4117,24 @@ const ifIdentifierErrors = (scope, decl) => {
 };
 
 const generateUnary = (scope, decl) => {
+  const toNumeric = () => {
+    // opt: skip if already known as number type
+    generate(scope, decl.argument); // hack: fix last type not being defined for getNodeType before generation
+    const known = knownType(scope, getNodeType(scope, decl.argument));
+    if (known === TYPES.number) return generate(scope, decl.argument);
+
+    return generate(scope, {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: '__ecma262_ToNumeric'
+      },
+      arguments: [
+        decl.argument
+      ]
+    });
+  };
+
   switch (decl.operator) {
     case '+':
       // opt: skip ToNumber if already known as number type
@@ -4085,21 +4160,31 @@ const generateUnary = (scope, decl) => {
     case '-':
       // +x * -1
 
-      if (decl.prefix && decl.argument.type === 'Literal' && typeof decl.argument.value === 'number') {
-        // if -n, just return that as a const
-        return [ number(-1 * decl.argument.value) ];
+      if (decl.prefix && decl.argument.type === 'Literal' && (typeof decl.argument.value === 'number' || typeof decl.argument.value === 'bigint')) {
+        // if -n, just return that as a literal
+        return generate(scope, {
+          type: 'Literal',
+          value: -decl.argument.value
+        });
       }
 
+      // todo: proper bigint support
       return [
-        ...generate(scope, {
-          type: 'UnaryExpression',
-          operator: '+',
-          prefix: true,
-          argument: decl.argument
-        }),
+        ...toNumeric(),
         ...(valtype === 'f64' ? [ [ Opcodes.f64_neg ] ] : [ number(-1), [ Opcodes.mul ] ])
       ];
 
+    case '~':
+      // todo: proper bigint support
+      return [
+        ...toNumeric(),
+        Opcodes.i32_to,
+        [ Opcodes.i32_const, ...signedLEB128(-1) ],
+        [ Opcodes.i32_xor ],
+        Opcodes.i32_from
+      ];
+
+
     case '!':
       const arg = decl.argument;
       if (arg.type === 'UnaryExpression' && arg.operator === '!') {
@@ -4110,20 +4195,6 @@ const generateUnary = (scope, decl) => {
       // !=
       return falsy(scope, generate(scope, arg), getNodeType(scope, arg), false, false);
 
-    case '~':
-      return [
-        ...generate(scope, {
-          type: 'UnaryExpression',
-          operator: '+',
-          prefix: true,
-          argument: decl.argument
-        }),
-        Opcodes.i32_to,
-        [ Opcodes.i32_const, ...signedLEB128(-1) ],
-        [ Opcodes.i32_xor ],
-        Opcodes.i32_from
-      ];
-
     case 'void': {
       // drop current expression value after running, give undefined
       const out = generate(scope, decl.argument);
@@ -4155,7 +4226,6 @@ const generateUnary = (scope, decl) => {
           ...toPropertyKey(scope, generate(scope, property), getNodeType(scope, property), decl.argument.computed, true),
 
           [ Opcodes.call, includeBuiltin(scope, scope.strict ? '__Porffor_object_deleteStrict' : '__Porffor_object_delete').index ],
-          [ Opcodes.drop ],
           Opcodes.i32_from_u
         ];
 
@@ -5616,10 +5686,7 @@ const generateObject = (scope, decl, global = false, name = '$undeclared') => {
         ...(kind !== 'init' ? [ Opcodes.i32_to_u ] : []),
         ...getNodeType(scope, value),
 
-        [ Opcodes.call, includeBuiltin(scope, `__Porffor_object_expr_${kind}`).index ],
-
-        [ Opcodes.drop ],
-        [ Opcodes.drop ]
+        [ Opcodes.call, includeBuiltin(scope, `__Porffor_object_expr_${kind}`).index ]
       );
     }
   }
@@ -6264,10 +6331,7 @@ const generateClass = (scope, decl) => {
       ...(initKind !== 'value' && initKind !== 'method' ? [ Opcodes.i32_to_u ] : []),
       ...getNodeType(outScope, value),
 
-      [ Opcodes.call, includeBuiltin(outScope, `__Porffor_object_class_${initKind}`).index ],
-
-      [ Opcodes.drop ],
-      [ Opcodes.drop ]
+      [ Opcodes.call, includeBuiltin(outScope, `__Porffor_object_class_${initKind}`).index ]
     );
   }
 
@@ -6287,7 +6351,7 @@ const generateClass = (scope, decl) => {
   return out;
 };
 
-export const generateTemplate = (scope, decl) => {
+const generateTemplate = (scope, decl) => {
   let current = null;
   const append = val => {
     if (!current) {
@@ -6575,9 +6639,10 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
                   number(0),
                   number(TYPES.undefined, Valtype.i32),
                   [ Opcodes.call, includeBuiltin(scope, '__Array_from').index ],
+                  [ Opcodes.local_set, func.locals[name].idx ],
 
+                  number(TYPES.array, Valtype.i32),
                   [ Opcodes.local_set, func.locals[name].idx + 1 ],
-                  [ Opcodes.local_set, func.locals[name].idx ],
                 [ Opcodes.end ]
               );
             }
@@ -6664,9 +6729,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
         // inject promise job runner func at the end of main if promises are made
         if (Object.hasOwn(funcIndex, 'Promise') || Object.hasOwn(funcIndex, '__Promise_resolve') || Object.hasOwn(funcIndex, '__Promise_reject')) {
           wasm.push(
-            [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_runJobs').index ],
-            [ Opcodes.drop ],
-            [ Opcodes.drop ]
+            [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_runJobs').index ]
           );
         }
       } else {
@@ -6687,14 +6750,12 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
           number(TYPES.array, Valtype.i32),
 
           [ Opcodes.call, includeBuiltin(func, func.async ? '__Porffor_AsyncGenerator' : '__Porffor_Generator').index ],
-          [ Opcodes.drop ],
           [ Opcodes.local_set, func.locals['#generator_out'].idx ]
         );
       } else if (func.async) {
         // make promise at the start
         wasm.unshift(
           [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_create').index ],
-          [ Opcodes.drop ],
           [ Opcodes.local_set, func.locals['#async_out_promise'].idx ],
 
           // wrap in try for later catch
@@ -6704,18 +6765,15 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
         // reject with thrown value if caught error
         wasm.push(
           [ Opcodes.catch, 0 ],
+            [ Opcodes.local_get, func.locals['#async_out_promise'].idx ],
+            number(TYPES.promise, Valtype.i32),
 
-          [ Opcodes.local_get, func.locals['#async_out_promise'].idx ],
-          number(TYPES.promise, Valtype.i32),
-
-          [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_reject').index ],
-          [ Opcodes.drop ],
-          [ Opcodes.drop ],
+            [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_reject').index ],
           [ Opcodes.end ],
 
           // return promise at the end of func
           [ Opcodes.local_get, func.locals['#async_out_promise'].idx ],
-          number(TYPES.promise, Valtype.i32),
+          ...(scope.returnType != null ? [] : [ number(TYPES.promise, Valtype.i32) ]),
           [ Opcodes.return ]
         );
 
@@ -6732,10 +6790,9 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
 
   if (typedInput && decl.returnType) {
     const { type } = extractTypeAnnotation(decl.returnType);
-    if (type != null && !Prefs.indirectCalls) {
-    // if (type != null) {
+    if (type != null) {
       func.returnType = type;
-      func.returns = [ valtypeBinary ];
+      func.returns = func.returnType === TYPES.undefined && !func.async && !func.generator ? [] : [ valtypeBinary ];
     }
   }
 
@@ -7008,8 +7065,6 @@ export default program => {
   Opcodes.load = [ Opcodes.i32_load, Opcodes.i64_load, Opcodes.f64_load ][valtypeInd];
   Opcodes.store = [ Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store ][valtypeInd];
 
-  Opcodes.lt = [ Opcodes.i32_lt_s, Opcodes.i64_lt_s, Opcodes.f64_lt ][valtypeInd];
-
   builtinFuncs = new BuiltinFuncs();
   builtinVars = new BuiltinVars({ builtinFuncs });
   prototypeFuncs = new PrototypeFuncs();

package/compiler/precompile.js

@@ -17,11 +17,10 @@ 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 ]
+    __Porffor_object_packAccessor: [ Valtype.f64 ]
   },
   params: {
     __Porffor_object_set: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
@@ -209,10 +208,11 @@ const precompile = async () => {
   }
 
   const total = performance.now() - t;
-  console.log(`\r${' '.repeat(80)}\r\u001b[2m${`[${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`);
+  console.log(`\r${' '.repeat(80)}\r\u001b[2m${`[${total.toFixed(2)}ms]`.padEnd(12, ' ')}\u001b[0m\u001b[92mcompiled ${funcs.length} funcs from ${fileCount} files\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}')`
+    hasFunc: x => `hasFunc('${x}')`,
+    hasType: x => `usedTypes.has(${TYPES[x]})`
   };
 
   return `// autogenerated by compiler/precompile.js
@@ -243,10 +243,10 @@ ${funcs.map(x => {
         });
 
         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 `[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}).slice(0,-1);Prefs=a;r();return b;}return []}]`;
       });
 
-    return `(_,{${str.includes('hasFunc(') ? 'hasFunc,' : ''}${str.includes('Valtype[') ? 'Valtype,' : ''}${str.includes('i32ify') ? 'i32ify,' : ''}${str.includes('Opcodes.') ? 'Opcodes,' : ''}${str.includes('...t(') ? 't,' : ''}${`${str.includes('allocPage(') ? 'allocPage,' : ''}${str.includes('makeString(') ? 'makeString,' : ''}${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;
+    return `(_,{${str.includes('usedTypes.') ? 'usedTypes,' : ''}${str.includes('hasFunc(') ? 'hasFunc,' : ''}${str.includes('Valtype[') ? 'Valtype,' : ''}${str.includes('i32ify') ? 'i32ify,' : ''}${str.includes('Opcodes.') ? 'Opcodes,' : ''}${str.includes('...t(') ? 't,' : ''}${`${str.includes('allocPage(') ? 'allocPage,' : ''}${str.includes('makeString(') ? 'makeString,' : ''}${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)
@@ -258,7 +258,7 @@ ${funcs.map(x => {
 
   return `this${name} = {
 wasm:${rewriteWasm(x.wasm)},
-params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.returns)},${x.returnType != null ? `returnType:${JSON.stringify(x.returnType)}` : 'typedReturns:1'},
+params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.returns)},${x.returnType != null ? `returnType:${JSON.stringify(x.returnType)},` : ''}
 locals:${JSON.stringify(locals.slice(x.params.length).map(x => x[1].type))},localNames:${JSON.stringify(locals.map(x => x[0]))},
 ${usedTypes.length > 0 ? `usedTypes:${JSON.stringify(usedTypes)},` : ''}
 ${x.globalInits ? `globalInits:{${Object.keys(x.globalInits).map(y => `${y}:${rewriteWasm(x.globalInits[y])}`).join(',')}},` : ''}${x.data && Object.keys(x.data).length > 0 ? `data:${JSON.stringify(x.data)},` : ''}

package/compiler/wrap.js

@@ -336,11 +336,16 @@ ${flags & 0b0001 ? `    get func idx: ${get}
     }
 
     case TYPES.bigint: {
+      if (Math.abs(value) < 0x8000000000000) {
+        return BigInt(value);
+      }
+      value -= 0x8000000000000;
+
       const negative = read(Uint8Array, memory, value, 1)[0] !== 0;
       const len = read(Uint16Array, memory, value + 2, 1)[0];
       const digits = read(Uint32Array, memory, value + 4, len);
 
-      console.log(digits);
+      if (Prefs.d) console.log(digits);
 
       let result = 0n;
       for (let i = 0; i < digits.length; i++) {
@@ -382,8 +387,8 @@ export default (source, module = undefined, customImports = {}, print = str => p
 
     const noAnsi = s => s && s.replace(/\u001b\[[0-9]+m/g, '');
     let longest = 0;
-    for (let j = 0; j < disassemble.length; j++) {
-      longest = Math.max(longest, noAnsi(disassemble[j])?.length ?? 0);
+    for (let j = 0; j < disasm.length; j++) {
+      longest = Math.max(longest, noAnsi(disasm[j])?.length ?? 0);
     }
 
     if (middleIndex != -1) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.55.17",
+  "version": "0.55.19",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/r.cjs

@@ -1,3 +1,5 @@
+
+
 // let o = { set foo(x) { console.log('set foo', x); }, __proto__: { set bar(x) { console.log('set bar', x); } } };
 
 // o.foo = 1;

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.55.17';
+globalThis.version = '0.55.19';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {