porffor 0.55.20 → 0.55.22

package/compiler/builtins/bigint.ts

@@ -5,11 +5,11 @@ export const __Porffor_bigint_fromDigits = (negative: boolean, digits: i32[]): b
   const len: i32 = digits.length;
   if (len > 16383) throw new RangeError('Maximum BigInt size exceeded'); // (65536 - 4) / 4
 
-  // const ptr: i32 = Porffor.allocate();
+  // use digits pointer as bigint pointer, as only used here
   let ptr: i32 = Porffor.wasm`local.get ${digits}`;
 
-  Porffor.wasm.i32.store8(ptr, negative ? 1 : 0, 0, 0);
-  Porffor.wasm.i32.store16(ptr, len, 0, 2);
+  Porffor.wasm.i32.store8(ptr, negative ? 1 : 0, 0, 0); // sign
+  Porffor.wasm.i32.store16(ptr, len, 0, 2); // digit count
 
   let allZero: boolean = true;
   for (let i: i32 = 0; i < len; i++) {
@@ -84,14 +84,10 @@ export const __Porffor_bigint_fromString = (n: string|bytestring): bigint => {
     offset = 1;
   }
 
-  // n -> digits (base 2^32) (most to least significant)
-  // 4294967294 -> [ 4294967294 ]
+  // n -> base 2^32 digits (most to least significant)
   // 4294967295 -> [ 4294967295 ]
   // 4294967296 -> [ 1, 0 ]
   // 4294967297 -> [ 1, 1 ]
-  // 9007199254740992 -> [ 2097152, 0 ]
-  // 9007199254740993 -> [ 2097152, 1 ]
-  // 9007199254740994 -> [ 2097152, 2 ]
 
   const BASE: i32 = 0x100000000; // 2^32
   const digits: i32[] = Porffor.allocate(); // todo: free later

package/compiler/codegen.js

@@ -10,14 +10,6 @@ import { log } from './log.js';
 import { allocPage, allocStr } from './allocator.js';
 import './prefs.js';
 
-let globals = {};
-let tags = [];
-let funcs = [];
-let exceptions = [];
-let funcIndex = {};
-let currentFuncIndex = importedFuncs.length;
-let builtinFuncs = {}, builtinVars = {}, prototypeFuncs = {};
-
 class TodoError extends Error {
   constructor(message) {
     super(message);
@@ -46,7 +38,6 @@ const cacheAst = (decl, wasm) => {
   return wasm;
 };
 
-let indirectFuncs = [];
 let doNotMarkFuncRef = false;
 const funcRef = func => {
   if (!doNotMarkFuncRef) func.referenced = true;
@@ -462,7 +453,7 @@ const lookup = (scope, name, failEarly = false) => {
   }
 
   if (local?.idx === undefined) {
-    if (name === 'arguments' && scope.name !== '#main' && !scope.arrow) {
+    if (name === 'arguments' && !scope.arrow) {
       // todo: not compliant
       let len = countLength(scope);
       const names = new Array(len);
@@ -1386,29 +1377,6 @@ const generateLogicExp = (scope, decl) => {
   return performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right));
 };
 
-// potential future ideas for nan boxing (unused):
-// T = JS type, V = value/pointer
-// 0bTTT
-// qNAN: 0 11111111111 1000000000000000000000000000000000000000000000000001
-// 50 bits usable: 0 11111111111 11??????????????????????????????????????????????????
-// js type: 4 bits
-// internal type: ? bits
-// pointer: 32 bits
-// https://piotrduperas.com/posts/nan-boxing
-// 0x7ffc000000000000
-// budget: 50 bits
-// js type: 4 bits
-// internal type: ? bits
-// pointer: 32 bits
-// generic
-// 1              23   4             5
-// 0 11111111111 11TTTTIIII??????????PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
-// 1: regular iEEE 754 double NaN
-// 2: extra 1 bit to identify NaN box
-// 3: js type
-// 4: internal type
-// 5: pointer
-
 const isExistingProtoFunc = name => {
   if (name.startsWith('__Array_prototype')) return !!prototypeFuncs[TYPES.array][name.slice(18)];
   if (name.startsWith('__String_prototype_')) return !!prototypeFuncs[TYPES.string][name.slice(19)];
@@ -1416,7 +1384,6 @@ const isExistingProtoFunc = name => {
   return false;
 };
 
-let globalInfer;
 const getInferred = (scope, name, global = false) => {
   if (global) {
     if (globalInfer.has(name)) return globalInfer.get(name);
@@ -1470,7 +1437,7 @@ const getType = (scope, name, failEarly = false) => {
     global = true;
   }
 
-  if (global !== false && name === 'arguments' && scope.name !== '#main' && !scope.arrow) {
+  if (global !== false && name === 'arguments' && !scope.arrow) {
     return [ number(TYPES.array, Valtype.i32) ];
   }
 
@@ -2750,18 +2717,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   out.push([ Opcodes.call, idx ]);
-
-  if (!typedReturns) {
-    // let type;
-    // if (builtinFuncs[name]) type = TYPES[builtinFuncs[name].returnType ?? 'number'];
-    // if (internalConstrs[name]) type = internalConstrs[name].type;
-    // if (importedFuncs[name] && importedFuncs[]) type =
-
-    // if (type) out.push(
-    //   number(type, Valtype.i32),
-    //   [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
-    // );
-  } else out.push(...setLastType(scope));
+  if (typedReturns) out.push(...setLastType(scope));
 
   if (
     func?.returns?.length === 0 ||
@@ -2941,8 +2897,7 @@ const brTable = (input, bc, returns) => {
   for (let i = offset; i <= max; i++) {
     // if branch for this num, go to that block
     if (bc[i]) {
-      table.push(br);
-      br++;
+      table.push(br++);
       continue;
     }
 
@@ -2979,9 +2934,6 @@ const brTable = (input, bc, returns) => {
   return out;
 };
 
-let typeswitchDepth = 0;
-
-let usedTypes = new Set();
 const typeUsed = (scope, x) => {
   if (x == null) return;
   usedTypes.add(x);
@@ -3137,7 +3089,7 @@ const typeIsNotOneOf = (type, types, valtype = Valtype.i32) => {
   return out;
 };
 
-const allocVar = (scope, name, global = false, type = true, redecl = false) => {
+const allocVar = (scope, name, global = false, type = true, redecl = false, i32 = false) => {
   const target = global ? globals : scope.locals;
 
   // already declared
@@ -3152,7 +3104,7 @@ const allocVar = (scope, name, global = false, type = true, redecl = false) => {
   }
 
   let idx = global ? globals['#ind']++ : scope.localInd++;
-  target[name] = { idx, type: valtypeBinary };
+  target[name] = { idx, type: i32 ? Valtype.i32 : valtypeBinary };
 
   if (type) {
     let typeIdx = global ? globals['#ind']++ : scope.localInd++;
@@ -3571,9 +3523,8 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
 const generateVar = (scope, decl) => {
   let out = [];
 
-  const topLevel = scope.name === '#main';
-
   // global variable if in top scope (main) or if internally wanted
+  const topLevel = scope.name === '#main';
   const global = decl._global ?? (topLevel || decl._bare);
 
   for (const x of decl.declarations) {
@@ -3635,8 +3586,16 @@ const memberTmpNames = scope => {
 };
 
 // COCTC: cross-object compile-time cache
-let coctc = new Map();
 const coctcOffset = prop => {
+  if (typeof prop === 'object') {
+    if (
+      prop.computed || prop.optional ||
+      ['prototype', 'size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'length', '__proto__'].includes(prop.property.name)
+    ) return 0;
+
+    prop = prop.property.name;
+  }
+
   let offset = coctc.get(prop);
   if (offset == null) {
     offset = (coctc.lastOffset ?? 60000) - 9;
@@ -3768,7 +3727,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
     // todo/perf: use i32 object (and prop?) locals
     const { objectTmp, propertyTmp, objectGet, propertyGet } = memberTmpNames(scope);
 
-    const useCoctc = Prefs.coctc && !decl.left.computed && !decl.left.optional && !['prototype', 'size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'length', '__proto__'].includes(decl.left.property.name) && coctcOffset(decl.left.property.name) > 0;
+    const useCoctc = Prefs.coctc && coctcOffset(decl.left) > 0;
     if (useCoctc) valueUnused = false;
 
     // opt: do not mark prototype funcs as referenced to optimize this in them
@@ -4214,7 +4173,7 @@ const generateUnary = (scope, decl) => {
         const property = getProperty(decl.argument);
         if (property.value === 'length' || property.value === 'name') scope.noFastFuncMembers = true;
 
-        const useCoctc = Prefs.coctc && !decl.argument.computed && !decl.argument.optional && !['prototype', 'size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'length', '__proto__'].includes(decl.argument.property.name) && coctcOffset(decl.argument.property.name) > 0;
+        const useCoctc = Prefs.coctc && coctcOffset(decl.argument) > 0;
         const objectTmp = useCoctc && localTmp(scope, '#coctc_object', Valtype.i32);
 
         const out = [
@@ -4453,7 +4412,6 @@ const generateConditional = (scope, decl) => {
   return out;
 };
 
-let depth = [];
 const generateFor = (scope, decl) => {
   const out = [];
 
@@ -5390,9 +5348,6 @@ const generateMeta = (scope, decl) => {
   return todo(scope, `meta property object ${decl.meta.name} is not supported yet`, true);
 };
 
-let pages = new Map();
-let data = [];
-
 const compileBytes = (val, itemType) => {
   switch (itemType) {
     case 'i8': return [ val % 256 ];
@@ -5410,7 +5365,7 @@ const makeData = (scope, elements, page = null, itemType = 'i8') => {
 
   const length = elements.length;
 
-  // if length is 0 memory/data will just be 0000... anyway
+  // if length is 0, memory/data will just be 0000... anyway
   if (length === 0) return false;
 
   let bytes = compileBytes(length, 'i32');
@@ -5424,7 +5379,6 @@ const makeData = (scope, elements, page = null, itemType = 'i8') => {
   }
 
   const obj = { bytes, page };
-
   const idx = data.push(obj) - 1;
 
   scope.data ??= [];
@@ -5448,63 +5402,6 @@ const printStaticStr = str => {
   return out;
 };
 
-const storeArray = (scope, array, index, element) => {
-  if (!Array.isArray(element)) element = generate(scope, element);
-  if (typeof index === 'number') index = [ number(index) ];
-
-  const offset = localTmp(scope, '#storeArray_offset', Valtype.i32);
-
-  return [
-    // calculate offset
-    ...index,
-    Opcodes.i32_to_u,
-    number(ValtypeSize[valtype] + 1, Valtype.i32),
-    [ Opcodes.i32_mul ],
-
-    ...array,
-    Opcodes.i32_to_u,
-    [ Opcodes.i32_add ],
-    [ Opcodes.local_set, offset ],
-
-    // store value
-    [ Opcodes.local_get, offset ],
-    ...generate(scope, element),
-    [ Opcodes.store, 0, ValtypeSize.i32 ],
-
-    // store type
-    [ Opcodes.local_get, offset ],
-    ...getNodeType(scope, element),
-    [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
-  ];
-};
-
-const loadArray = (scope, array, index) => {
-  if (typeof index === 'number') index = [ number(index) ];
-
-  const offset = localTmp(scope, '#loadArray_offset', Valtype.i32);
-
-  return [
-    // calculate offset
-    ...index,
-    Opcodes.i32_to_u,
-    number(ValtypeSize[valtype] + 1, Valtype.i32),
-    [ Opcodes.i32_mul ],
-
-    ...array,
-    Opcodes.i32_to_u,
-    [ Opcodes.i32_add ],
-    [ Opcodes.local_set, offset ],
-
-    // load value
-    [ Opcodes.local_get, offset ],
-    [ Opcodes.load, 0, ValtypeSize.i32 ],
-
-    // load type
-    [ Opcodes.local_get, offset ],
-    [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
-  ];
-};
-
 const byteStringable = str => {
   for (let i = 0; i < str.length; i++) {
     if (str.charCodeAt(i) > 0xFF) return false;
@@ -5943,14 +5840,27 @@ const generateMember = (scope, decl, _global, _name) => {
     }
   }
 
-  const useCoctc = Prefs.coctc && !decl.computed && !decl.optional && !['prototype', 'size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength', 'length', '__proto__'].includes(decl.property.name) && coctcOffset(decl.property.name) > 0;
+  const useCoctc = Prefs.coctc && coctcOffset(decl) > 0;
   const coctcObjTmp = useCoctc && localTmp(scope, '#coctc_obj' + uniqId(), Valtype.i32);
 
   const out = typeSwitch(scope, getNodeType(scope, object), {
     ...(decl.computed ? {
       [TYPES.array]: () => [
-        ...loadArray(scope, [ objectGet ], [ propertyGet ]),
-        ...setLastType(scope)
+        propertyGet,
+        Opcodes.i32_to_u,
+        number(ValtypeSize[valtype] + 1, Valtype.i32),
+        [ Opcodes.i32_mul ],
+
+        objectGet,
+        Opcodes.i32_to_u,
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_tee, localTmp(scope, '#loadArray_offset', Valtype.i32) ],
+        [ Opcodes.load, 0, ValtypeSize.i32 ],
+
+        ...setLastType(scope, [
+          [ Opcodes.local_get, localTmp(scope, '#loadArray_offset', Valtype.i32) ],
+          [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
+        ])
       ],
 
       [TYPES.string]: () => [
@@ -6291,18 +6201,6 @@ const generateClass = (scope, decl) => {
     // default value to undefined
     value ??= DEFAULT_VALUE();
 
-    let outArr = out, outOp = 'push', outScope = scope;
-    if (type === 'PropertyDefinition' && !_static) {
-      // define in construction instead
-      outArr = func.wasm;
-      outOp = 'unshift';
-      object = {
-        type: 'ThisExpression',
-        _noGlobalThis: true
-      };
-      outScope = func;
-    }
-
     if (isFuncType(value.type)) {
       let id = value.id;
 
@@ -6320,19 +6218,60 @@ const generateClass = (scope, decl) => {
       };
     }
 
-    outArr[outOp](
-      ...generate(outScope, object),
-      Opcodes.i32_to_u,
-      ...getNodeType(outScope, object),
+    if (type === 'PropertyDefinition' && !_static) {
+      // define in construction instead
+      object = {
+        type: 'ThisExpression',
+        _noGlobalThis: true
+      };
 
-      ...toPropertyKey(outScope, generate(outScope, k), getNodeType(outScope, k), computed, true),
+      let computedTmp;
+      if (computed) {
+        // compute now, reference in construction
+        computedTmp = allocVar(scope, `#class_computed_prop${uniqId()}`, true, true, false, true);
 
-      ...generate(outScope, value),
-      ...(initKind !== 'value' && initKind !== 'method' ? [ Opcodes.i32_to_u ] : []),
-      ...getNodeType(outScope, value),
+        out.push(
+          ...toPropertyKey(scope, generate(scope, k), getNodeType(scope, k), computed, true),
+          [ Opcodes.global_set, computedTmp + 1 ],
+          [ Opcodes.global_set, computedTmp ]
+        );
+      }
 
-      [ Opcodes.call, includeBuiltin(outScope, `__Porffor_object_class_${initKind}`).index ]
-    );
+      func.wasm.unshift(
+        ...generate(func, object),
+        Opcodes.i32_to_u,
+        ...getNodeType(func, object),
+
+        ...(computed ? [
+          [ Opcodes.global_get, computedTmp ],
+          [ Opcodes.global_get, computedTmp + 1 ],
+        ] : [
+          ...generate(func, k),
+          Opcodes.i32_to_u,
+          ...getNodeType(func, k)
+        ]),
+
+        ...generate(func, value),
+        ...(initKind !== 'value' && initKind !== 'method' ? [ Opcodes.i32_to_u ] : []),
+        ...getNodeType(func, value),
+
+        [ Opcodes.call, includeBuiltin(func, `__Porffor_object_class_${initKind}`).index ]
+      );
+    } else {
+      out.push(
+        ...generate(scope, object),
+        Opcodes.i32_to_u,
+        ...getNodeType(scope, object),
+
+        ...toPropertyKey(scope, generate(scope, k), getNodeType(scope, k), computed, true),
+
+        ...generate(scope, value),
+        ...(initKind !== 'value' && initKind !== 'method' ? [ Opcodes.i32_to_u ] : []),
+        ...getNodeType(scope, value),
+
+        [ Opcodes.call, includeBuiltin(scope, `__Porffor_object_class_${initKind}`).index ]
+      );
+    }
   }
 
   delete scope.overrideThis;
@@ -6855,7 +6794,6 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
   return [ func, out ];
 };
 
-let largestBlockBody = 0;
 const generateBlock = (scope, decl) => {
   let out = [];
 
@@ -6863,10 +6801,8 @@ const generateBlock = (scope, decl) => {
   scope.inferTree.push(decl);
 
   let len = decl.body.length, j = 0;
-  if (len > largestBlockBody) largestBlockBody = len;
   for (let i = 0; i < len; i++) {
     const x = decl.body[i];
-    if (len >= largestBlockBody) globalThis.progress?.(`${i}/${len}`);
     if (isEmptyNode(x)) continue;
 
     if (j++ > 0) out.push([ Opcodes.drop ]);
@@ -7029,10 +6965,9 @@ const internalConstrs = {
   }
 };
 
+let globals, tags, exceptions, funcs, indirectFuncs, funcIndex, currentFuncIndex, depth, pages, data, typeswitchDepth, usedTypes, coctc, globalInfer, builtinFuncs, builtinVars, prototypeFuncs;
 export default program => {
-  globals = {
-    ['#ind']: 0
-  };
+  globals = { ['#ind']: 0 };
   tags = [];
   exceptions = [];
   funcs = []; indirectFuncs = [];
@@ -7042,26 +6977,22 @@ export default program => {
   data = [];
   currentFuncIndex = importedFuncs.length;
   typeswitchDepth = 0;
-  largestBlockBody = 0;
   usedTypes = new Set([ TYPES.empty, TYPES.undefined, TYPES.number, TYPES.boolean, TYPES.function ]);
   coctc = new Map();
   globalInfer = new Map();
 
-  const valtypeInd = ['i32', 'i64', 'f64'].indexOf(valtype);
-
   // set generic opcodes for current valtype
+  const valtypeInd = ['i32', 'i64', 'f64'].indexOf(valtype);
   Opcodes.const = [ Opcodes.i32_const, Opcodes.i64_const, Opcodes.f64_const ][valtypeInd];
   Opcodes.eq = [ Opcodes.i32_eq, Opcodes.i64_eq, Opcodes.f64_eq ][valtypeInd];
   Opcodes.eqz = [ [ [ Opcodes.i32_eqz ] ], [ [ Opcodes.i64_eqz ] ], [ number(0), [ Opcodes.f64_eq ] ] ][valtypeInd];
   Opcodes.mul = [ Opcodes.i32_mul, Opcodes.i64_mul, Opcodes.f64_mul ][valtypeInd];
   Opcodes.add = [ Opcodes.i32_add, Opcodes.i64_add, Opcodes.f64_add ][valtypeInd];
   Opcodes.sub = [ Opcodes.i32_sub, Opcodes.i64_sub, Opcodes.f64_sub ][valtypeInd];
-
   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];
-
   Opcodes.load = [ Opcodes.i32_load, Opcodes.i64_load, Opcodes.f64_load ][valtypeInd];
   Opcodes.store = [ Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store ][valtypeInd];
 
@@ -7072,28 +7003,24 @@ export default program => {
   const getObjectName = x => x.startsWith('__') && x.slice(2, x.indexOf('_', 2));
   objectHackers = ['assert', 'compareArray', 'Test262Error', ...new Set(Object.keys(builtinFuncs).map(getObjectName).concat(Object.keys(builtinVars).map(getObjectName)).filter(x => x))];
 
-  program.id = { name: '#main' };
-
-  program.body = {
-    type: 'BlockStatement',
-    body: program.body
-  };
-
-  if (Prefs.astLog) console.log(JSON.stringify(program.body.body, null, 2));
-
-  const [ main ] = generateFunc({}, program);
+  const [ main ] = generateFunc({}, {
+    type: 'Program',
+    id: { name: '#main' },
+    body: {
+      type: 'BlockStatement',
+      body: program.body
+    }
+  });
 
   // if wanted and blank main func and other exports, remove it
   if (Prefs.rmBlankMain && main.wasm.length === 0 && funcs.some(x => x.export)) funcs.splice(main.index - importedFuncs.length, 1);
 
-  // make ~empty funcs for never generated funcs
-  // 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;
+    const wasm = f.wasm;
+    if (wasm) {
+      // func was generated, run callback ops
       for (let j = 0; j < wasm.length; j++) {
         const o = wasm[j];
         if (o[0] === null && typeof o[1] === 'function') {
@@ -7104,14 +7031,8 @@ export default program => {
       continue;
     }
 
-    // make wasm just return 0s for expected returns
+    // func was never generated, make wasm just return 0s for expected returns
     f.wasm = f.returns.map(x => number(0, x));
-
-    // alternative: make func empty, may break some indirect calls
-    // f.wasm = [];
-    // f.returns = [];
-    // f.params = [];
-    // f.locals = {};
   }
 
   // // remove never generated functions
@@ -7151,10 +7072,9 @@ export default program => {
   for (let i = 0; i < indirectFuncs.length; i++) {
     const f = indirectFuncs[i];
     f.index = currentFuncIndex++;
+    funcs.push(f);
   }
 
-  funcs.push(...indirectFuncs);
-
   delete globals['#ind'];
 
   return { funcs, globals, tags, exceptions, pages, data };

package/package.json

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

package/r.cjs

@@ -1,4 +1,10 @@
+class C {
+  [(() => { return Math.random(); })()] = 1337;
+}
 
+console.log(new C());
+console.log(new C());
+console.log(new C());
 
 // 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.20';
+globalThis.version = '0.55.22';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {