porffor 0.55.18 → 0.55.20

package/compiler/codegen.js

@@ -505,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 [
@@ -1004,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
 
@@ -1218,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];
@@ -1289,7 +1301,7 @@ const asmFuncToAsm = (scope, func) => {
         return [ [ null, () => {
           if (types.some(x => usedTypes.has(x))) return wasm();
           return [];
-        }, 0 ] ];
+        } ] ];
       }
     },
     i32ify: wasm => {
@@ -1439,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) ];
 
@@ -1636,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) ||
@@ -1667,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;
     }
 
@@ -1773,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);
   }
@@ -1833,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 [
@@ -2774,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 ]
   ];
@@ -3056,7 +3094,7 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary, fallthrough = fals
             depth = oldDepth;
           }
           return out;
-        }, 0 ]);
+        } ]);
       }
     }
   }
@@ -4079,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
@@ -4104,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 === '!') {
@@ -4129,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);
@@ -6299,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) {
@@ -7013,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

@@ -211,7 +211,8 @@ const precompile = async () => {
   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
@@ -242,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)

package/compiler/wrap.js

@@ -335,6 +335,25 @@ ${flags & 0b0001 ? `    get func idx: ${get}
       return out;
     }
 
+    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);
+
+      if (Prefs.d) console.log(digits);
+
+      let result = 0n;
+      for (let i = 0; i < digits.length; i++) {
+        result = result * 0x100000000n + BigInt(digits[i]);
+      }
+      return negative ? -result : result;
+    }
+
     default: return value;
   }
 };

package/package.json

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

package/r.cjs

@@ -1,4 +1,4 @@
-Array.from.call(null, 0);
+
 
 // let o = { set foo(x) { console.log('set foo', x); }, __proto__: { set bar(x) { console.log('set bar', x); } } };
 

package/runner/index.js

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