porffor 0.42.0 → 0.42.1

package/compiler/codegen.js

@@ -66,6 +66,34 @@ const funcRef = func => {
     }
     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++) {
@@ -427,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) => {
@@ -1061,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 = [];
@@ -1134,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);
 
@@ -4604,9 +4676,20 @@ const generateLabel = (scope, decl) => {
   return generate(scope, decl.body);
 };
 
+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;
@@ -4617,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);
@@ -4637,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) => {
@@ -4692,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 ]);
     }
@@ -5633,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
@@ -5943,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() {
@@ -6031,6 +6104,9 @@ const generateFunc = (scope, decl) => {
           ...number(TYPES.promise, Valtype.i32),
           [ Opcodes.return ]
         );
+
+        // ensure tag exists for specific catch
+        ensureTag();
       }
 
       if (name === 'main') {

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