porffor 0.55.21 → 0.55.23

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;
@@ -1393,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);
@@ -1549,7 +1539,7 @@ const getNodeType = (scope, node) => {
       return getType(scope, node.name);
     }
 
-    if (node.type === 'ObjectExpression') {
+    if (node.type === 'ObjectExpression' || node.type === 'Super') {
       return TYPES.object;
     }
 
@@ -1581,24 +1571,6 @@ const getNodeType = (scope, node) => {
       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
-      // if so and there is only one impl (eg charCodeAt)
-      // or all impls have the same return type
-      // use that return type as that is the only possibility
-      // (if non-matching type it would error out)
-      if (name.startsWith('__')) {
-        const spl = name.slice(2).split('_');
-
-        const func = spl[spl.length - 1];
-        const protoFuncs = Object.keys(prototypeFuncs).filter(x => x != TYPES.bytestring && prototypeFuncs[x][func] != null);
-        if (
-          protoFuncs.length === 1 ||
-          (protoFuncs.length > 1 && protoFuncs.every(x => x.returnType === protoFuncs[0].returnType))
-        ) {
-          if (protoFuncs[0].returnType != null) return protoFuncs[0].returnType;
-        }
-      }
-
       if (name.startsWith('__Porffor_wasm_')) {
         // todo: return undefined for non-returning ops
         return TYPES.number;
@@ -1870,29 +1842,6 @@ const createNewTarget = (scope, decl, idx = 0, force = false) => {
   ];
 };
 
-const makeObject = (scope, obj) => {
-  const properties = [];
-  for (const x in obj) {
-    properties.push({
-      type: 'Property',
-      method: false,
-      shorthand: false,
-      computed: false,
-      key: {
-        type: 'Identifier',
-        name: x
-      },
-      value: obj[x],
-      kind: 'init'
-    });
-  }
-
-  return generate(scope, {
-    type: 'ObjectExpression',
-    properties
-  });
-};
-
 const getObjProp = (obj, prop) => {
   if (typeof obj === 'string') obj = {
     type: 'Identifier',
@@ -1977,32 +1926,22 @@ const createThisArg = (scope, decl) => {
       number(TYPES.object, Valtype.i32)
     ];
 
-    // create new object with __proto__ set to callee prototype
+    // create new object with prototype set to callee prototype
     const tmp = localTmp(scope, '#this_create_tmp');
     const proto = getObjProp(decl.callee, 'prototype');
 
     return [
-      ...makeObject(scope, {}),
+      [ Opcodes.call, includeBuiltin(scope, '__Porffor_allocate').index ],
+      Opcodes.i32_from_u,
       [ Opcodes.local_tee, tmp ],
       Opcodes.i32_to_u,
-
       number(TYPES.object, Valtype.i32),
 
-      ...generate(scope, {
-        type: 'Literal',
-        value: '__proto__'
-      }),
-      Opcodes.i32_to_u,
-      number(TYPES.bytestring, Valtype.i32),
-
       ...generate(scope, proto),
+      Opcodes.i32_to_u,
       ...getNodeType(scope, proto),
 
-      // flags: writable
-      number(0b1000, Valtype.i32),
-      number(TYPES.number, Valtype.i32),
-
-      [ Opcodes.call, includeBuiltin(scope, '__Porffor_object_expr_initWithFlags').index ],
+      [ Opcodes.call, includeBuiltin(scope, '__Porffor_object_setPrototype').index ],
 
       [ Opcodes.local_get, tmp ],
       number(TYPES.object, Valtype.i32)
@@ -2363,30 +2302,34 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${protoName}_tmp2`, protoFunc.local2) : -1;
 
           let optUnused = false;
-          const protoOut = protoFunc(getPointer, {
-            getCachedI32: () => [ [ Opcodes.local_get, lengthLocal ] ],
-            setCachedI32: () => [ [ Opcodes.local_set, lengthLocal ] ],
-            get: () => ArrayUtil.getLength(getPointer),
-            getI32: () => ArrayUtil.getLengthI32(getPointer),
-            set: value => ArrayUtil.setLength(getPointer, value),
-            setI32: value => ArrayUtil.setLengthI32(getPointer, value)
-          },
-          generate(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
-          getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
-          protoLocal, protoLocal2,
-          bytes => [
-            number(bytes, Valtype.i32),
-            [ Opcodes.call, includeBuiltin(scope, '__Porffor_allocateBytes').index ]
-          ],
-          () => {
-            optUnused = true;
-            return unusedValue;
+          const protoOut = protoFunc({
+            pointer: getPointer,
+            length: {
+              getCachedI32: () => [ [ Opcodes.local_get, lengthLocal ] ],
+              setCachedI32: () => [ [ Opcodes.local_set, lengthLocal ] ],
+              get: () => ArrayUtil.getLength(getPointer),
+              getI32: () => ArrayUtil.getLengthI32(getPointer),
+              set: value => ArrayUtil.setLength(getPointer, value),
+              setI32: value => ArrayUtil.setLengthI32(getPointer, value)
+            },
+            arg: generate(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
+            argType: getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
+            iTmp: protoLocal,
+            iTmp2: protoLocal2,
+            alloc: bytes => [
+              number(bytes, Valtype.i32),
+              [ Opcodes.call, includeBuiltin(scope, '__Porffor_allocateBytes').index ]
+            ],
+            unusedValue: () => {
+              optUnused = true;
+              return unusedValue;
+            },
+            setType: type => setLastType(scope, type)
           });
 
           return [
             [ Opcodes.block, unusedValue ? Blocktype.void : valtypeBinary ],
               ...protoOut,
-              ...(unusedValue && optUnused ? [] : (protoFunc.returnType != null ? setLastType(scope, protoFunc.returnType) : setLastType(scope))),
               ...(unusedValue && !optUnused ? [ [ Opcodes.drop ] ] : []),
             [ Opcodes.end ]
           ];
@@ -2784,8 +2727,19 @@ const generateThis = (scope, decl) => {
   ];
 };
 
-const generateSuper = (scope, decl) => generate(scope,
-  getObjProp(getObjProp({ type: 'ThisExpression', _noGlobalThis: true }, '__proto__'), '__proto__'));
+const generateSuper = (scope, decl) => generate(scope, {
+  type: 'CallExpression',
+  callee: { type: 'Identifier', name: '__Porffor_object_getPrototype' },
+  arguments: [
+    {
+      type: 'CallExpression',
+      callee: { type: 'Identifier', name: '__Porffor_object_getPrototype' },
+      arguments: [
+        { type: 'ThisExpression', _noGlobalThis: true }
+      ]
+    }
+  ]
+});
 
 // bad hack for undefined and null working without additional logic
 const DEFAULT_VALUE = () => ({
@@ -2907,8 +2861,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;
     }
 
@@ -2945,9 +2898,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);
@@ -3103,7 +3053,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
@@ -3118,7 +3068,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++;
@@ -3600,7 +3550,6 @@ const memberTmpNames = scope => {
 };
 
 // COCTC: cross-object compile-time cache
-let coctc = new Map();
 const coctcOffset = prop => {
   if (typeof prop === 'object') {
     if (
@@ -4427,7 +4376,6 @@ const generateConditional = (scope, decl) => {
   return out;
 };
 
-let depth = [];
 const generateFor = (scope, decl) => {
   const out = [];
 
@@ -4903,7 +4851,7 @@ const generateForIn = (scope, decl) => {
 
     // get length
     [ Opcodes.local_get, pointer ],
-    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+    [ Opcodes.i32_load16_u, 0, 0 ],
     [ Opcodes.local_tee, length ],
 
     [ Opcodes.if, Blocktype.void ]
@@ -4936,7 +4884,7 @@ const generateForIn = (scope, decl) => {
 
     // read key
     [ Opcodes.local_get, pointer ],
-    [ Opcodes.i32_load, 0, 5 ],
+    [ Opcodes.i32_load, 0, 12 ],
     [ Opcodes.local_tee, tmp ],
 
     ...setType(scope, tmpName, [
@@ -4968,7 +4916,7 @@ const generateForIn = (scope, decl) => {
     // todo/perf: do not read key for non-enumerables
     // only run body if entry is enumerable
     [ Opcodes.local_get, pointer ],
-    [ Opcodes.i32_load8_u, 0, 17 ],
+    [ Opcodes.i32_load8_u, 0, 24 ],
     [ Opcodes.i32_const, 0b0100 ],
     [ Opcodes.i32_and ],
     [ Opcodes.if, Blocktype.void ],
@@ -4976,9 +4924,9 @@ const generateForIn = (scope, decl) => {
     [ Opcodes.drop ],
     [ Opcodes.end ],
 
-    // increment pointer by 14
+    // increment pointer by 18
     [ Opcodes.local_get, pointer ],
-    number(14, Valtype.i32),
+    number(18, Valtype.i32),
     [ Opcodes.i32_add ],
     [ Opcodes.local_set, pointer ],
 
@@ -5364,9 +5312,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 ];
@@ -5805,60 +5750,6 @@ const generateMember = (scope, decl, _global, _name) => {
     if (known == null) extraBC = bc;
   }
 
-  if (decl.property.name === '__proto__') {
-    // todo: support optional
-    const bc = {};
-    const prototypes = Object.keys(builtinVars).filter(x => x.endsWith('_prototype'));
-
-    const known = knownType(scope, getNodeType(scope, decl.object));
-    for (const x of prototypes) {
-      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))
-      ];
-      if (type === known) return bc[type]();
-    }
-
-    if (known == null) {
-      aliasPrimObjsBC(bc);
-      extraBC = bc;
-    }
-  }
-
   const useCoctc = Prefs.coctc && coctcOffset(decl) > 0;
   const coctcObjTmp = useCoctc && localTmp(scope, '#coctc_obj' + uniqId(), Valtype.i32);
 
@@ -6028,7 +5919,7 @@ const generateMember = (scope, decl, _global, _name) => {
       }),
     } : {}),
 
-    [TYPES.undefined]: internalThrow(scope, 'TypeError', 'Cannot read property of undefined', true),
+    [TYPES.undefined]: internalThrow(scope, 'TypeError', `Cannot read property of undefined`, true),
 
     // default: internalThrow(scope, 'TypeError', 'Unsupported member expression object', true)
     default: () => [
@@ -6183,10 +6074,25 @@ const generateClass = (scope, decl) => {
       // class Foo {}
       // class Bar extends Foo {}
       // Bar.__proto__ = Foo
-      // Bar.prototype.__proto__ = Foo.prototype
-      ...generate(scope, setObjProp(root, '__proto__', decl.superClass)),
+      ...generate(scope, {
+        type: 'CallExpression',
+        callee: { type: 'Identifier', name: '__Porffor_object_setPrototype' },
+        arguments: [
+          root,
+          decl.superClass
+        ]
+      }),
       [ Opcodes.drop ],
-      ...generate(scope, setObjProp(proto, '__proto__', getObjProp(decl.superClass, 'prototype'))),
+
+      // Bar.prototype.__proto__ = Foo.prototype
+      ...generate(scope, {
+        type: 'CallExpression',
+        callee: { type: 'Identifier', name: '__Porffor_object_setPrototype' },
+        arguments: [
+          proto,
+          getObjProp(decl.superClass, 'prototype')
+        ]
+      }),
       [ Opcodes.drop ]
     );
   }
@@ -6220,18 +6126,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;
 
@@ -6249,19 +6143,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;
@@ -6344,7 +6279,7 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
               return funcIndex[x];
             }
 
-            return scope.locals[x]?.idx ?? globals[x].idx;
+            return scope.locals[x]?.idx ?? globals[x]?.idx ?? (log.warning('codegen', `unknown immediate in Porffor.wasm: ${x}`) || 0);
           }
 
           return n;
@@ -6418,7 +6353,6 @@ const objectHack = node => {
 
       // hack: block these properties as they can be accessed on functions
       if (node.object.name !== 'Porffor' && (node.property.name === 'length' || node.property.name === 'name' || node.property.name === 'call')) return abortOut;
-
       if (node.property.name === '__proto__') return abortOut;
 
       let objectName = node.object.name;
@@ -6784,7 +6718,6 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
   return [ func, out ];
 };
 
-let largestBlockBody = 0;
 const generateBlock = (scope, decl) => {
   let out = [];
 
@@ -6792,10 +6725,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 ]);
@@ -6958,10 +6889,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 = [];
@@ -6971,26 +6901,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];
 

package/compiler/precompile.js

@@ -1,6 +1,6 @@
 import { Opcodes, Valtype } from './wasmSpec.js';
 import { read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
-import { TYPES } from './types.js';
+import { TYPES, TYPE_NAMES } from './types.js';
 import { log } from './log.js';
 
 import process from 'node:process';
@@ -41,7 +41,7 @@ const compile = async (file, _funcs) => {
   let first = source.slice(0, source.indexOf('\n'));
 
   if (first.startsWith('export default')) {
-    source = await (await import('file://' + file)).default();
+    source = await (await import('file://' + file)).default({ TYPES, TYPE_NAMES });
     first = source.slice(0, source.indexOf('\n'));
   }
 
@@ -155,11 +155,10 @@ const compile = async (file, _funcs) => {
         }
 
         if (n[0] === Opcodes.throw) {
-          if (!bodyHasTopLevelThrow && depth === 0) log.warning('codegen', `top-level throw in ${x.name}`);
-
           x.usesTag = true;
+          let id;
           if (y[0] === Opcodes.i32_const && n[1] === 0) {
-            const id = read_signedLEB128(y.slice(1));
+            id = read_signedLEB128(y.slice(1));
             y.splice(0, 10, 'throw', exceptions[id].constructor, exceptions[id].message);
 
             // remove throw inst
@@ -167,6 +166,8 @@ const compile = async (file, _funcs) => {
           } else {
             n[1]--;
           }
+
+          if (!bodyHasTopLevelThrow && depth === 0) log.warning('codegen', `top-level throw in ${x.name} (${exceptions[id].constructor}: ${exceptions[id].message})`);
         }
 
         if (n[0] === Opcodes.catch) {