porffor 0.41.7 → 0.42.1

package/compiler/codegen.js

@@ -48,6 +48,7 @@ const cacheAst = (decl, wasm) => {
   return wasm;
 };
 
+let indirectFuncs = [];
 const funcRef = func => {
   func.generate?.();
 
@@ -55,35 +56,81 @@ const funcRef = func => {
     [ Opcodes.const, 'funcref', func.name ]
   ];
 
-  const wrapperArgc = Prefs.indirectWrapperArgc ?? 6;
-  if (func.returns.length === 2 && countParams(func) < wrapperArgc && !func.wrapperFunc) {
+  const wrapperArgc = Prefs.indirectWrapperArgc ?? 8;
+  if (!func.wrapperFunc) {
     const locals = {}, params = [];
-    for (let i = 0; i < wrapperArgc + (func.constr ? 2 : 0); i++) {
+    for (let i = 0; i < wrapperArgc + 2; 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;
+    let localInd = (wrapperArgc + 2) * 2;
+
+    if (indirectFuncs.length === 0) {
+      // add empty indirect func
+      const emptyFunc = {
+        name: '#indirect#empty',
+        params,
+        locals: { ...locals }, localInd,
+        returns: [ valtypeBinary, Valtype.i32 ],
+        wasm: [
+          ...number(0),
+          ...number(0, Valtype.i32)
+        ],
+        constr: true,
+        internal: true,
+        indirect: true
+      };
+
+      // check not being constructed
+      emptyFunc.wasm.unshift(
+        [ Opcodes.local_get, 0 ], // new.target value
+        Opcodes.i32_to_u,
+        [ Opcodes.if, Blocktype.void ], // if value is non-zero
+          ...internalThrow(emptyFunc, 'TypeError', `Function is not a constructor`), // throw type error
+        [ Opcodes.end ]
+      );
+
+      indirectFuncs.push(emptyFunc);
+    }
 
     const wasm = [];
+    const offset = func.constr ? 0 : 4;
     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 ]: [])
-      );
+      if (func.internal && func.name.includes('_prototype_') && i < 2) {
+        // special case: use real this for prototype internals
+        wasm.push(
+          [ Opcodes.local_get, 2 + i ],
+          ...(i % 2 === 0 && func.params[i] === Valtype.i32 ? [ Opcodes.i32_to ]: [])
+        );
+      } else {
+        wasm.push(
+          [ Opcodes.local_get, offset + (!func.internal || func.typedParams ? i : i * 2) ],
+          ...(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 };
+      if (func.returns.length === 2) {
+        const localIdx = localInd++;
+        locals[localIdx] = { idx: localIdx, type: Valtype.i32 };
 
-      wasm.push(
-        [ Opcodes.local_set, localIdx ],
-        Opcodes.i32_from,
-        [ Opcodes.local_get, localIdx ]
-      );
+        wasm.push(
+          [ Opcodes.local_set, localIdx ],
+          Opcodes.i32_from,
+          [ Opcodes.local_get, localIdx ]
+        );
+      } else {
+        wasm.push(Opcodes.i32_from);
+      }
+    }
+
+    if (func.returns.length === 1) {
+      // add built-in returnType if only returns a value
+      wasm.push(...number(func.returnType ?? TYPES.number, Valtype.i32));
     }
 
     const name = '#indirect_' + func.name;
@@ -93,16 +140,26 @@ const funcRef = func => {
       locals, localInd,
       returns: [ valtypeBinary, Valtype.i32 ],
       wasm,
-      constr: func.constr,
+      constr: true,
       internal: true,
-      index: currentFuncIndex++
+      indirect: true
     };
 
-    funcs.push(wrapperFunc);
-    funcIndex[name] = wrapperFunc.index;
+    indirectFuncs.push(wrapperFunc);
 
     wrapperFunc.jsLength = countLength(func);
     func.wrapperFunc = wrapperFunc;
+
+    if (!func.constr) {
+      // check not being constructed
+      wasm.unshift(
+        [ Opcodes.local_get, 0 ], // new.target value
+        Opcodes.i32_to_u,
+        [ Opcodes.if, Blocktype.void ], // if value is non-zero
+          ...internalThrow(wrapperFunc, 'TypeError', `${unhackName(func.name)} is not a constructor`), // throw type error
+        [ Opcodes.end ]
+      );
+    }
   }
 
   return [
@@ -398,32 +455,75 @@ const generateReturn = (scope, decl) => {
     ];
   }
 
-  const out = [];
   if (
     scope.constr && // only do this in constructors
     !globalThis.precompile // skip in precompiled built-ins, we should not require this and handle it ourselves
   ) {
-    // ignore return value and return this if being constructed
-    // todo: only do this when trying to return a primitive?
-    out.push(
-      // ...truthy(scope, [ [ Opcodes.local_get, scope.locals['#newtarget'].idx ] ], [ [ Opcodes.local_get, scope.locals['#newtarget#type'].idx ] ], false, true),
-      [ Opcodes.local_get, scope.locals['#newtarget'].idx ],
-      Opcodes.i32_to_u,
-      [ Opcodes.if, Blocktype.void ],
-        [ Opcodes.local_get, scope.locals['#this'].idx ],
-        ...(scope.returnType != null ? [] : [ [ Opcodes.local_get, scope.locals['#this#type'].idx ] ]),
-        [ Opcodes.return ],
-      [ Opcodes.end ]
-    );
+    // perform return value checks for constructors and (sub)classes
+    return [
+      ...generate(scope, arg),
+      [ Opcodes.local_set, localTmp(scope, '#return') ],
+      ...(scope.returnType != null ? [] : getNodeType(scope, arg)),
+      [ Opcodes.local_set, localTmp(scope, '#return#type', Valtype.i32) ],
+
+      ...(scope._onlyConstr ? [] : [
+        [ Opcodes.local_get, scope.locals['#newtarget'].idx ],
+        Opcodes.i32_to_u,
+        [ Opcodes.if, Blocktype.void ]
+      ]),
+        ...(scope.subclass ? [
+          // if subclass and returning undefined, return this
+          [ Opcodes.local_get, localTmp(scope, '#return#type') ],
+          ...number(TYPE_FLAGS.parity, Valtype.i32),
+          [ Opcodes.i32_or ],
+          ...number(TYPES.undefined, Valtype.i32),
+          [ Opcodes.i32_eq ],
+          [ Opcodes.if, Blocktype.void ],
+            [ Opcodes.local_get, scope.locals['#this'].idx ],
+            ...(scope.returnType != null ? [] : [ [ Opcodes.local_get, scope.locals['#this#type'].idx ] ]),
+            [ Opcodes.return ],
+          [ Opcodes.end ]
+        ] : []),
+
+        // if not object, then...
+        ...generate(scope, {
+          type: 'CallExpression',
+          callee: {
+            type: 'Identifier',
+            name: '__Porffor_object_isObject'
+          },
+          arguments: [
+            { type: 'Identifier', name: '#return' }
+          ]
+        }),
+        Opcodes.i32_to_u,
+        [ Opcodes.i32_eqz ],
+        [ Opcodes.if, Blocktype.void ],
+          ...(scope.subclass ? [
+            // throw if subclass
+            ...internalThrow(scope, 'TypeError', 'Subclass can only return an object or undefined'),
+          ] : [
+            // return this if not subclass
+            [ Opcodes.local_get, scope.locals['#this'].idx ],
+            ...(scope.returnType != null ? [] : [ [ Opcodes.local_get, scope.locals['#this#type'].idx ] ]),
+            [ Opcodes.return ],
+          ]),
+        [ Opcodes.end ],
+      ...(scope._onlyConstr ? [] : [
+        [ Opcodes.end ]
+      ]),
+
+      [ Opcodes.local_get, localTmp(scope, '#return') ],
+      [ Opcodes.local_get, localTmp(scope, '#return#type') ],
+      [ Opcodes.return ]
+    ];
   }
 
-  out.push(
+  return [
     ...generate(scope, arg),
     ...(scope.returnType != null ? [] : getNodeType(scope, arg)),
     [ Opcodes.return ]
-  );
-
-  return out;
+  ];
 };
 
 const localTmp = (scope, name, type = valtypeBinary) => {
@@ -1032,7 +1132,7 @@ const asmFuncToAsm = (scope, func) => {
   });
 };
 
-const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTypes = [], globals: globalTypes = [], globalInits = [], returns = [], returnType, localNames = [], globalNames = [], data: _data = [], table = false, constr = false, hasRestArgument = false, usedTypes = [] } = {}) => {
+const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTypes = [], globals: globalTypes = [], globalInits = [], returns = [], returnType, localNames = [], globalNames = [], data: _data = [], table = false, constr = false, hasRestArgument = false, usesTag = false, usedTypes = [] } = {}) => {
   if (wasm == null) { // called with no builtin
     log.warning('codegen', `${name} has no built-in!`);
     wasm = [];
@@ -1105,6 +1205,7 @@ const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTy
   }
 
   if (hasRestArgument) func.hasRestArgument = true;
+  if (usesTag) ensureTag();
 
   for (const x of usedTypes) typeUsed(func, x);
 
@@ -2233,7 +2334,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       scope.table = true;
 
       let args = decl.arguments;
-      const wrapperArgc = Prefs.indirectWrapperArgc ?? 6;
+      const wrapperArgc = Prefs.indirectWrapperArgc ?? 8;
       if (args.length < wrapperArgc) {
         args = args.concat(new Array(wrapperArgc - args.length).fill(DEFAULT_VALUE()));
       }
@@ -2293,39 +2394,14 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
         ...typeSwitch(scope, getNodeType(scope, callee), {
           [TYPES.function]: () => [
-            // get if func we are calling is a constructor or not
+            ...forceDuoValtype(scope, newTargetWasm, Valtype.f64),
+            ...forceDuoValtype(scope, thisWasm, Valtype.f64),
+            ...out,
+
             [ Opcodes.local_get, calleeLocal ],
             Opcodes.i32_to_u,
-            ...number(48, Valtype.i32),
-            [ Opcodes.i32_mul ],
-            ...number(2, Valtype.i32),
-            [ Opcodes.i32_add ],
-            [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut')), 'read func lut' ],
-
-            ...number(0b10, Valtype.i32),
-            [ Opcodes.i32_and ],
-            [ Opcodes.if, Valtype.f64 ],
-              ...forceDuoValtype(scope, newTargetWasm, Valtype.f64),
-              ...forceDuoValtype(scope, thisWasm, Valtype.f64),
-              ...out,
-
-              [ 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 ]
+            [ Opcodes.call_indirect, args.length + 2, 0 ],
+            ...setLastType(scope)
           ],
 
           default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, Valtype.f64)
@@ -2362,16 +2438,12 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     paramOffset += 4;
   }
 
-  if (func && !func.hasRestArgument && args.length < paramCount) {
+  if (func && args.length < paramCount) {
     // too little args, push undefineds
-    args = args.concat(new Array(paramCount - args.length).fill(DEFAULT_VALUE()));
+    args = args.concat(new Array(paramCount - (func.hasRestArgument ? 1 : 0) - args.length).fill(DEFAULT_VALUE()));
   }
 
   if (func && func.hasRestArgument) {
-    if (args.length < paramCount) {
-      args = args.concat(new Array(paramCount - 1 - args.length).fill(DEFAULT_VALUE()));
-    }
-
     const restArgs = args.slice(paramCount - 1);
     args = args.slice(0, paramCount - 1);
     args.push({
@@ -2385,13 +2457,18 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     args = args.slice(0, paramCount);
   }
 
-  if (func && func.throws) scope.throws = true;
-
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (Array.isArray(arg)) {
       // if wasm, just append it
       out = out.concat(arg);
+
+      if (valtypeBinary !== Valtype.i32 &&
+        (func && func.params[paramOffset + i * (typedParams ? 2 : 1)] === Valtype.i32)
+      ) {
+        out.push(...forceDuoValtype(scope, [], Valtype.i32));
+      }
+
       continue;
     }
 
@@ -3662,8 +3739,11 @@ const generateUnary = (scope, decl) => {
     case 'delete': {
       if (decl.argument.type === 'MemberExpression') {
         const object = decl.argument.object;
-        const property = getProperty(decl.argument);
 
+        // disallow `delete super.*`
+        if (object.type === 'Super') return internalThrow(scope, 'ReferenceError', 'Cannot delete super property', true);
+
+        const property = getProperty(decl.argument);
         if (property.value === 'length' || property.value === 'name') scope.noFastFuncMembers = true;
 
         return [
@@ -4596,11 +4676,20 @@ const generateLabel = (scope, decl) => {
   return generate(scope, decl.body);
 };
 
-const generateThrow = (scope, decl) => {
-  scope.throws = true;
+const ensureTag = (exceptionMode = Prefs.exceptionMode ?? 'stack') => {
+  if (tags.length !== 0) return;
+
+  tags.push({
+    params: exceptionMode === 'lut' ? [ Valtype.i32 ] : [ valtypeBinary, Valtype.i32 ],
+    results: [],
+    idx: tags.length
+  });
+};
 
+const generateThrow = (scope, decl) => {
   let exceptionMode = Prefs.exceptionMode ?? 'stack';
   if (globalThis.precompile) exceptionMode = decl.argument.callee != null ? 'lut' : 'stack';
+  ensureTag(exceptionMode);
 
   if (exceptionMode === 'lut') {
     let message = decl.argument.value, constructor = null;
@@ -4611,12 +4700,6 @@ const generateThrow = (scope, decl) => {
       message = decl.argument.arguments[0]?.value ?? '';
     }
 
-    if (tags.length === 0) tags.push({
-      params: [ Valtype.i32 ],
-      results: [],
-      idx: tags.length
-    });
-
     if (constructor && constructor.startsWith('__')) constructor = constructor.split('_').pop();
 
     let exceptId = exceptions.findIndex(x => x.constructor === constructor && x.message === message);
@@ -4631,19 +4714,11 @@ const generateThrow = (scope, decl) => {
     ];
   }
 
-  if (exceptionMode === 'stack') {
-    if (tags.length === 0) tags.push({
-      params: [ valtypeBinary, Valtype.i32 ],
-      results: [],
-      idx: tags.length
-    });
-
-    return [
-      ...generate(scope, decl.argument),
-      ...getNodeType(scope, decl.argument),
-      [ Opcodes.throw, globalThis.precompile ? 1 : 0 ]
-    ];
-  }
+  return [
+    ...generate(scope, decl.argument),
+    ...getNodeType(scope, decl.argument),
+    [ Opcodes.throw, globalThis.precompile ? 1 : 0 ]
+  ];
 };
 
 const generateTry = (scope, decl) => {
@@ -4686,6 +4761,9 @@ const generateTry = (scope, decl) => {
 
         ...generateVarDstr(scope, 'let', param, { type: 'Identifier', name: tmpName }, undefined, false)
       );
+
+      // ensure tag exists for specific catch
+      ensureTag();
     } else {
       out.push([ Opcodes.catch_all ]);
     }
@@ -5056,11 +5134,7 @@ const toPropertyKey = (scope, wasm, type, computed = false, i32Conv = false) =>
   ...wasm,
   ...type,
   [ Opcodes.call, includeBuiltin(scope, '__ecma262_ToPropertyKey').index ],
-  ...(i32Conv ? [
-    [ Opcodes.local_set, localTmp(scope, '#swap', Valtype.i32) ],
-    Opcodes.i32_to_u,
-    [ Opcodes.local_get, localTmp(scope, '#swap', Valtype.i32) ]
-  ] : [])
+  ...(i32Conv ? forceDuoValtype(scope, [], Valtype.i32) : [])
 ] : [
   ...wasm,
   ...(i32Conv ? [ Opcodes.i32_to_u ] : []),
@@ -5203,7 +5277,6 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
   if (decl.property.name === 'name' && hasFuncWithName(name) && !scope.noFastFuncMembers) {
     // eg: __String_prototype_toLowerCase -> toLowerCase
     if (name.startsWith('__')) name = name.split('_').pop();
-    if (name.startsWith('#indirect_')) name = name.slice(10);
     if (name.startsWith('#')) name = '';
 
     return withType(scope, makeString(scope, name, _global, _name, true), TYPES.bytestring);
@@ -5620,16 +5693,7 @@ const generateClass = (scope, decl) => {
     type: 'Identifier',
     name
   };
-  const proto = {
-    type: 'MemberExpression',
-    object: root,
-    property: {
-      type: 'Identifier',
-      name: 'prototype'
-    },
-    computed: false,
-    optional: false
-  };
+  const proto = getObjProp(root, 'prototype');
 
   const [ func, out ] = generateFunc(scope, {
     ...(body.find(x => x.kind === 'constructor')?.value ?? {
@@ -5641,9 +5705,10 @@ const generateClass = (scope, decl) => {
       }
     }),
     id: root,
-    _onlyConstr: true,
     strict: true,
-    type: expr ? 'FunctionExpression' : 'FunctionDeclaration'
+    type: expr ? 'FunctionExpression' : 'FunctionDeclaration',
+    _onlyConstr: true,
+    _subclass: !!decl.superClass
   });
 
   // always generate class constructor funcs
@@ -5656,7 +5721,7 @@ const generateClass = (scope, decl) => {
       // Bar.__proto__ = Foo
       // Bar.prototype.__proto__ = Foo.prototype
       ...generate(scope, setObjProp(root, '__proto__', decl.superClass)),
-      ...generate(scope, setObjProp(getObjProp(root, 'prototype'), '__proto__', getObjProp(decl.superClass, 'prototype')))
+      ...generate(scope, setObjProp(proto, '__proto__', getObjProp(decl.superClass, 'prototype')))
     );
   }
 
@@ -5951,7 +6016,7 @@ const generateFunc = (scope, decl) => {
     index: currentFuncIndex++,
     arrow,
     constr: !arrow && !decl.generator && !decl.async,
-    _onlyConstr: decl._onlyConstr, _onlyThisMethod: decl._onlyThisMethod,
+    subclass: decl._subclass, _onlyConstr: decl._onlyConstr, _onlyThisMethod: decl._onlyThisMethod,
     strict: scope.strict || decl.strict,
 
     generate() {
@@ -6039,6 +6104,9 @@ const generateFunc = (scope, decl) => {
           ...number(TYPES.promise, Valtype.i32),
           [ Opcodes.return ]
         );
+
+        // ensure tag exists for specific catch
+        ensureTag();
       }
 
       if (name === 'main') {
@@ -6339,7 +6407,7 @@ export default program => {
   };
   tags = [];
   exceptions = [];
-  funcs = [];
+  funcs = []; indirectFuncs = [];
   funcIndex = {};
   depth = [];
   pages = new Map();
@@ -6394,6 +6462,7 @@ export default program => {
   // 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;
@@ -6450,9 +6519,15 @@ export default program => {
   //   }
   // }
 
-  delete globals['#ind'];
+  // add indirect funcs to end of funcs
+  for (let i = 0; i < indirectFuncs.length; i++) {
+    const f = indirectFuncs[i];
+    f.index = currentFuncIndex++;
+  }
+
+  funcs.push(...indirectFuncs);
 
-  // console.log([...usedTypes].map(x => TYPE_NAMES[x]));
+  delete globals['#ind'];
 
   return { funcs, globals, tags, exceptions, pages, data };
 };

package/compiler/precompile.js

@@ -153,6 +153,7 @@ const compile = async (file, _funcs) => {
         }
 
         if (n[0] === Opcodes.throw) {
+          x.usesTag = true;
           if (y[0] === Opcodes.i32_const && n[1] === 0) {
             const id = read_signedLEB128(y.slice(1));
             y.splice(0, 10, 'throw', exceptions[id].constructor, exceptions[id].message);
@@ -163,6 +164,10 @@ const compile = async (file, _funcs) => {
             n[1]--;
           }
         }
+
+        if (n[0] === Opcodes.catch) {
+          x.usesTag = true;
+        }
       }
     };
 
@@ -251,7 +256,7 @@ params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.retu
 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)},` : ''}
-${x.table ? `table:1,` : ''}${x.constr ? `constr:1,` : ''}${x.hasRestArgument ? `hasRestArgument:1,` : ''}
+${x.table ? `table:1,` : ''}${x.constr ? `constr:1,` : ''}${x.hasRestArgument ? `hasRestArgument:1,` : ''}${x.usesTag ? `usesTag:1,` : ''}
 }`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll('\n\n', '\n');
 }).join('\n')}
 }`;

package/compiler/wrap.js

@@ -520,12 +520,10 @@ export default (source, module = undefined, customImports = {}, print = str => p
             throw new constructor(exception.message);
           }
 
-          if (exceptionMode === 'stack') {
-            const value = e.getArg(exceptTag, 0);
-            const type = e.getArg(exceptTag, 1);
+          const value = e.getArg(exceptTag, 0);
+          const type = e.getArg(exceptTag, 1);
 
-            throw porfToJSValue({ memory, funcs, pages }, value, type);
-          }
+          throw porfToJSValue({ memory, funcs, pages }, value, type);
         }
 
         if (e instanceof WebAssembly.RuntimeError) {

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.7+89be416c1",
+  "version": "0.42.1+240c1785e",
   "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.7+89be416c1';
+globalThis.version = '0.42.1+240c1785e';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {