porffor 0.17.0-55999d22b → 0.17.0-94400a2b8

package/compiler/codegen.js

@@ -264,10 +264,12 @@ const internalThrow = (scope, constructor, message, expectsValue = Prefs.alwaysV
     argument: {
       type: 'NewExpression',
       callee: {
+        type: 'Identifier',
         name: constructor
       },
       arguments: [
         {
+          type: 'Literal',
           value: message
         }
       ]
@@ -289,12 +291,13 @@ const generateIdent = (scope, decl) => {
       return wasm.slice();
     }
 
-    if (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(internalConstrs, name)) {
-      // todo: return an actual something
-      return number(1);
-    }
+    // todo: enable this by default in future
+    // if (!Object.hasOwn(funcIndex, name) && Object.hasOwn(builtinFuncs, name)) {
+    //   includeBuiltin(scope, name);
+    //   return number(funcIndex[name] - importedFuncs.length);
+    // }
 
-    if (isExistingProtoFunc(name)) {
+    if (isExistingProtoFunc(name) || Object.hasOwn(internalConstrs, name) || Object.hasOwn(builtinFuncs, name)) {
       // todo: return an actual something
       return number(1);
     }
@@ -973,6 +976,33 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 };
 
 const generateBinaryExp = (scope, decl, _global, _name) => {
+  if (decl.operator === 'instanceof') {
+    // very hacky basic instanceof
+    // todo: support dynamic right-hand side
+
+    const out = generate(scope, decl.left);
+    disposeLeftover(out);
+
+    const rightName = decl.right.name;
+    if (!rightName) return todo(scope, 'instanceof dynamic right-hand side is not supported yet', true);
+
+    const checkType = TYPES[rightName.toLowerCase()];
+    if (checkType == null || rightName !== TYPE_NAMES[checkType] || checkType === TYPES.undefined) return todo(scope, 'instanceof right-hand side type unsupported', true);
+
+    if ([TYPES.number, TYPES.boolean, TYPES.string, TYPES.symbol, TYPES.object].includes(checkType)) {
+      out.push(...number(0));
+    } else {
+      out.push(
+        ...getNodeType(scope, decl.left),
+        ...number(checkType, Valtype.i32),
+        [ Opcodes.i32_eq ],
+        Opcodes.i32_from_u
+      );
+    }
+
+    return out;
+  }
+
   const out = performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name);
 
   if (valtype !== 'i32' && ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(decl.operator)) out.push(Opcodes.i32_from_u);
@@ -1279,7 +1309,7 @@ const getNodeType = (scope, node) => {
     }
 
     if (node.type === 'BinaryExpression') {
-      if (['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(node.operator)) return TYPES.boolean;
+      if (['==', '===', '!=', '!==', '>', '>=', '<', '<=', 'instanceof'].includes(node.operator)) return TYPES.boolean;
       if (node.operator !== '+') return TYPES.number;
 
       const knownLeft = knownType(scope, getNodeType(scope, node.left));
@@ -3029,32 +3059,101 @@ const generateLabel = (scope, decl) => {
 const generateThrow = (scope, decl) => {
   scope.throws = true;
 
-  let message = decl.argument.value, constructor = null;
+  const exceptionMode = Prefs.exceptionMode ?? 'lut';
+  if (exceptionMode === 'lut') {
+    let message = decl.argument.value, constructor = null;
+
+    // support `throw (new)? Error(...)`
+    if (!message && (decl.argument.type === 'NewExpression' || decl.argument.type === 'CallExpression')) {
+      constructor = decl.argument.callee.name;
+      message = decl.argument.arguments[0]?.value ?? '';
+    }
+
+    if (tags.length === 0) tags.push({
+      params: [ Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
+
+    let exceptId = exceptions.push({ constructor, message }) - 1;
+
+    scope.exceptions ??= [];
+    scope.exceptions.push(exceptId);
+
+    return [
+      [ Opcodes.i32_const, signedLEB128(exceptId) ],
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
 
-  // hack: throw new X("...") -> throw "..."
-  if (!message && (decl.argument.type === 'NewExpression' || decl.argument.type === 'CallExpression')) {
-    constructor = decl.argument.callee.name;
-    message = decl.argument.arguments[0]?.value ?? '';
+  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, tags[0].idx ]
+    ];
   }
 
-  if (tags.length === 0) tags.push({
-    params: [ Valtype.i32 ],
-    results: [],
-    idx: tags.length
-  });
+  if (exceptionMode === 'stackest') {
+    let message = decl.argument, constructor = null;
 
-  let exceptId = exceptions.push({ constructor, message }) - 1;
-  let tagIdx = tags[0].idx;
+    // support `throw (new)? Error(...)`
+    if (message.type === 'NewExpression' || message.type === 'CallExpression') {
+      constructor = decl.argument.callee;
+      message = decl.argument.arguments[0];
+    }
 
-  scope.exceptions ??= [];
-  scope.exceptions.push(exceptId);
+    message ??= DEFAULT_VALUE;
 
-  // todo: write a description of how this works lol
+    if (tags.length === 0) tags.push({
+      params: [ valtypeBinary, valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
 
-  return [
-    [ Opcodes.i32_const, signedLEB128(exceptId) ],
-    [ Opcodes.throw, tagIdx ]
-  ];
+    return [
+      ...(constructor == null ? number(-1) : generate(scope, constructor)),
+      ...generate(scope, message),
+      ...getNodeType(scope, message),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
+
+  if (exceptionMode === 'partial') {
+    let message = decl.argument, constructor = null;
+
+    // support `throw (new)? Error(...)`
+    if (message.type === 'NewExpression' || message.type === 'CallExpression') {
+      constructor = decl.argument.callee.name;
+      message = decl.argument.arguments[0];
+    }
+
+    message ??= DEFAULT_VALUE;
+
+    if (tags.length === 0) tags.push({
+      params: [ Valtype.i32, valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
+
+    let exceptId = exceptions.push({ constructor }) - 1;
+
+    scope.exceptions ??= [];
+    scope.exceptions.push(exceptId);
+
+    return [
+      [ Opcodes.i32_const, signedLEB128(exceptId) ],
+      ...generate(scope, message),
+      ...getNodeType(scope, message),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
 };
 
 const generateTry = (scope, decl) => {
@@ -3772,7 +3871,7 @@ const internalConstrs = {
 
       // todo: check in wasm instead of here
       const literalValue = arg.value ?? 0;
-      if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeThrow', 'Invalid array length', true);
+      if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeError', 'Invalid array length', true);
 
       return [
         ...out,

package/compiler/wrap.js

@@ -127,7 +127,7 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
 
   globalThis.porfDebugInfo = { funcs, globals };
 
-  if (source.includes?.('export ')) flags.push('module');
+  if (process.argv[1].includes('/runner') && source.includes?.('export ')) flags.push('module');
 
   // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
@@ -297,16 +297,58 @@ export default (source, flags = [ 'module' ], customImports = {}, print = str =>
         return porfToJSValue({ memory, funcs, pages }, ret[0], ret[1]);
       } catch (e) {
         if (e.is && e.is(exceptTag)) {
-          const exceptId = e.getArg(exceptTag, 0);
-          const exception = exceptions[exceptId];
+          const exceptionMode = Prefs.exceptionMode ?? 'lut';
+          if (exceptionMode === 'lut') {
+            const exceptId = e.getArg(exceptTag, 0);
+            const exception = exceptions[exceptId];
 
-          const constructorName = exception.constructor;
+            const constructorName = exception.constructor;
 
-          // no constructor, just throw message
-          if (!constructorName) throw exception.message;
+            // no constructor, just throw message
+            if (!constructorName) throw exception.message;
 
-          const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
-          throw new constructor(exception.message);
+            const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+            throw new constructor(exception.message);
+          }
+
+          if (exceptionMode === 'stack') {
+            const value = e.getArg(exceptTag, 0);
+            const type = e.getArg(exceptTag, 1);
+
+            throw porfToJSValue({ memory, funcs, pages }, value, type);
+          }
+
+          if (exceptionMode === 'stackest') {
+            const constructorIdx = e.getArg(exceptTag, 0);
+            const constructorName = constructorIdx == -1 ? null : funcs.find(x => ((x.originalIndex ?? x.index) - importedFuncs.length) === constructorIdx)?.name;
+
+            const value = e.getArg(exceptTag, 1);
+            const type = e.getArg(exceptTag, 2);
+            const message = porfToJSValue({ memory, funcs, pages }, value, type);
+
+            // no constructor, just throw message
+            if (!constructorName) throw message;
+
+            const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+            throw new constructor(message);
+          }
+
+          if (exceptionMode === 'partial') {
+            const exceptId = e.getArg(exceptTag, 0);
+            const exception = exceptions[exceptId];
+
+            const constructorName = exception.constructor;
+
+            const value = e.getArg(exceptTag, 1);
+            const type = e.getArg(exceptTag, 2);
+            const message = porfToJSValue({ memory, funcs, pages }, value, type);
+
+            // no constructor, just throw message
+            if (!constructorName) throw message;
+
+            const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+            throw new constructor(message);
+          }
         }
 
         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.17.0-55999d22b",
+  "version": "0.17.0-94400a2b8",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

@@ -145,7 +145,9 @@ try {
   // if (cache) process.stdout.write(cache);
 } catch (e) {
   // if (cache) process.stdout.write(cache);
-  console.error(process.argv.includes('-i') ? e : `${e.constructor.name}: ${e.message}`);
+  let out = e;
+  if (!process.argv.includes('-i') && e.__proto__.message != null) out = `${e.constructor.name}${e.message != null ? `: ${e.message}` : ''}`;
+  console.error(out);
 }
 
 if (process.argv.includes('-t')) console.log(`${process.argv.includes('-b') ? '' : '\n\n'}total time: ${(performance.now() - start).toFixed(2)}ms\nexecution time: ${(performance.now() - runStart).toFixed(2)}ms`);