porffor 0.2.0-9ca9aed → 0.2.0-aea77ff

package/README.md

@@ -1,5 +1,5 @@
 # Porffor &nbsp;<sup><sub>/ˈpɔrfɔr/ &nbsp;*(poor-for)*</sup></sub>
-A from-scratch experimental **AOT** optimizing JS -> Wasm/C engine/compiler/runtime in JS. Not serious/intended for (real) use. (this is a straight forward, honest readme)<br>
+A from-scratch experimental **AOT** optimizing JS/TS -> Wasm/C engine/compiler/runtime in JS. Not serious/intended for (real) use. (this is a straight forward, honest readme)<br>
 Age: ~6 months (very on and off)
 
 ## Design
@@ -118,7 +118,7 @@ No particular order and no guarentees, just what could happen soon™
 - Objects
   - Basic object expressions (eg `{}`, `{ a: 0 }`)
 - Wasm
-  - *Basic* Wasm engine (interpreter) in js
+  - *Basic* Wasm engine (interpreter) in JS
 - More math operators (`**`, etc)
 - `do { ... } while (...)`
 - Rewrite `console.log` to work with strings/arrays
@@ -130,7 +130,21 @@ No particular order and no guarentees, just what could happen soon™
   - Rewrite local indexes per func for smallest local header and remove unused idxs
   - Smarter inline selection (snapshots?)
   - Remove const ifs (`if (true)`, etc)
-  - Use type(script) information to remove unneeded typechecker code
+  - Experiment with byte strings?
+- Runtime
+  - WASI target
+  - Run precompiled Wasm file if given
+- Cool proposals
+  - [Optional Chaining Assignment](https://github.com/tc39/proposal-optional-chaining-assignment)
+  - [Modulus and Additional Integer Math](https://github.com/tc39/proposal-integer-and-modulus-math)
+  - [Array Equality](https://github.com/tc39/proposal-array-equality)
+  - [Declarations in Conditionals](https://github.com/tc39/proposal-Declarations-in-Conditionals)
+  - [Seeded Pseudo-Random Numbers](https://github.com/tc39/proposal-seeded-random)
+  - [`do` expressions](https://github.com/tc39/proposal-do-expressions)
+  - [String Trim Characters](https://github.com/Kingwl/proposal-string-trim-characters)
+- Posts
+  - Inlining investigation
+- Self hosted testing?
 
 ## Performance
 *For the things it supports most of the time*, Porffor is blazingly fast compared to most interpreters, and common engines running without JIT. For those with JIT, it is not that much slower like a traditional interpreter would be; mostly the same or a bit faster/slower depending on what.
@@ -157,10 +171,12 @@ Mostly for reducing size. I do not really care about compiler perf/time as long
 - Remove unneeded blocks (no `br`s inside)
 - Remove unused imports
 - Use data segments for initing arrays/strings
+- (Likely more not documented yet, todo)
 
 ### Wasm module
 - Type cache/index (no repeated types)
 - No main func if empty (and other exports)
+- No tags if unused/optimized out
 
 ## Test262
 Porffor can run Test262 via some hacks/transforms which remove unsupported features whilst still doing the same asserts (eg simpler error messages using literals only). It currently passes >10% (see latest commit desc for latest and details). Use `node test262` to test, it will also show a difference of overall results between the last commit and current results.
@@ -180,7 +196,7 @@ Porffor can run Test262 via some hacks/transforms which remove unsupported featu
   - `wasmSpec.js`: "enums"/info from wasm spec
   - `wrap.js`: wrapper for compiler which instantiates and produces nice exports
 
-- `runner`: contains utils for running js with the compiler
+- `runner`: contains utils for running JS with the compiler
   - `index.js`: the main file, you probably want to use this
   - `info.js`: runs with extra info printed
   - `repl.js`: basic repl (uses `node:repl`)
@@ -212,11 +228,14 @@ You can also use Deno (`deno run -A ...` instead of `node ...`), or Bun (`bun ..
 - `-target=native` only:
   - `-compiler=clang` to set compiler binary (path/name) to use to compile
   - `-cO=O3` to set compiler opt argument
+- `-parser=acorn|@babel/parser|meriyah|hermes-parser` (default: `acorn`) to set which parser to use
+- `-parse-types` to enable parsing type annotations/typescript. if `-parser` is unset, changes default to `@babel/parser`. does not type check
+- `-opt-types` to perform optimizations using type annotations as compiler hints. does not type check
 - `-valtype=i32|i64|f64` (default: `f64`) to set valtype
 - `-O0` to disable opt
 - `-O1` (default) to enable basic opt (simplify insts, treeshake wasm imports)
-- `-O2` to enable advanced opt (inlining)
-- `-O3` to enable advanceder opt (precompute const math)
+- `-O2` to enable advanced opt (inlining). unstable
+- `-O3` to enable advanceder opt (precompute const math). unstable
 - `-no-run` to not run wasm output, just compile
 - `-opt-log` to log some opts
 - `-code-log` to log some codegen (you probably want `-funcs`)
@@ -230,20 +249,20 @@ You can also use Deno (`deno run -A ...` instead of `node ...`), or Bun (`bun ..
 - `-compile-hints` to enable V8 compilation hints (experimental + doesn't seem to do much?)
 
 ## VSCode extension
-There is a vscode extension in `porffor-for-vscode` which tweaks js syntax highlighting to be nicer with porffor features (eg highlighting wasm inside of inline asm).
+There is a vscode extension in `porffor-for-vscode` which tweaks JS syntax highlighting to be nicer with porffor features (eg highlighting wasm inside of inline asm).
 
 ## Isn't this the same as AssemblyScript/other Wasm langs?
 No. they are not alike at all internally and have very different goals/ideals:
 - Porffor is made as a generic JS engine, not for Wasm stuff specifically
-- Porffor takes in JS, not a different language or typescript
-- Porffor is made in pure JS and compiles itself, not using Binaryen/etc
+- Porffor primarily consumes JS
+- Porffor is written in pure JS and compiles itself, not using Binaryen/etc
 - (Also I didn't know it existed when I started this, lol)
 
 ## FAQ
 
 ### 1. Why the name?
 `purple` in Welsh is `porffor`. Why purple?
-- No other js engine is purple colored
+- No other JS engine is purple colored
 - Purple is pretty cool
 - Purple apparently represents "ambition", which is.. one word to describe this project
 - The hard to speak name is also the noise your brain makes in reaction to this idea!

package/compiler/builtins.js

@@ -1,4 +1,4 @@
-import { Blocktype, Opcodes, Valtype } from "./wasmSpec.js";
+import { Blocktype, Opcodes, Valtype, ValtypeSize } from "./wasmSpec.js";
 import { number, i32x4 } from "./embedding.js";
 
 export const importedFuncs = [
@@ -29,6 +29,21 @@ for (let i = 0; i < importedFuncs.length; i++) {
 
 const char = c => number(c.charCodeAt(0));
 
+const printStaticStr = str => {
+  const out = [];
+
+  for (let i = 0; i < str.length; i++) {
+    out.push(
+      // ...number(str.charCodeAt(i)),
+      ...number(str.charCodeAt(i), Valtype.i32),
+      Opcodes.i32_from_u,
+      [ Opcodes.call, importedFuncs.printChar ]
+    );
+  }
+
+  return out;
+};
+
 // todo: somehow diff between these (undefined != null) while remaining falsey in wasm as a number value
 export const UNDEFINED = 0;
 export const NULL = 0;
@@ -187,12 +202,125 @@ export const BuiltinFuncs = function() {
 
 
   this.__console_log = {
-    params: [ valtypeBinary ],
-    locals: [],
+    params: [ valtypeBinary, Valtype.i32 ],
+    typedParams: true,
+    locals: [ Valtype.i32, Valtype.i32 ],
     returns: [],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.call, importedFuncs.print ],
+    wasm: (scope, { TYPES, typeSwitch }) => [
+      ...typeSwitch(scope, [ [ Opcodes.local_get, 1 ] ], {
+        [TYPES.number]: [
+          [ Opcodes.local_get, 0 ],
+          [ Opcodes.call, importedFuncs.print ],
+        ],
+        [TYPES.boolean]: [
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.if, Blocktype.void ],
+          ...printStaticStr('true'),
+          [ Opcodes.else ],
+          ...printStaticStr('false'),
+          [ Opcodes.end ]
+        ],
+        [TYPES.string]: [
+          // simply print a string :))
+          // cache input pointer as i32
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.local_tee, 2 ],
+
+          // make end pointer
+          [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+          ...number(ValtypeSize.i16, Valtype.i32),
+          [ Opcodes.i32_mul ],
+
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_set, 3 ],
+
+          [ Opcodes.loop, Blocktype.void ],
+
+          // print current char
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+          Opcodes.i32_from_u,
+          [ Opcodes.call, importedFuncs.printChar ],
+
+          // increment pointer by sizeof i16
+          [ Opcodes.local_get, 2 ],
+          ...number(ValtypeSize.i16, Valtype.i32),
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_tee, 2 ],
+
+          // if pointer != end pointer, loop
+          [ Opcodes.local_get, 3 ],
+          [ Opcodes.i32_ne ],
+          [ Opcodes.br_if, 0 ],
+
+          [ Opcodes.end ]
+        ],
+        [TYPES._array]: [
+          ...printStaticStr('[ '),
+
+          // cache input pointer as i32
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.local_tee, 2 ],
+
+          // make end pointer
+          [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+          ...number(ValtypeSize[valtype], Valtype.i32),
+          [ Opcodes.i32_mul ],
+
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_set, 3 ],
+
+          [ Opcodes.loop, Blocktype.void ],
+
+          // print current char
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.load, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+          [ Opcodes.call, importedFuncs.print ],
+
+          // increment pointer by sizeof valtype
+          [ Opcodes.local_get, 2 ],
+          ...number(ValtypeSize[valtype], Valtype.i32),
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_tee, 2 ],
+
+          // if pointer != end pointer, print separator and loop
+          [ Opcodes.local_get, 3 ],
+          [ Opcodes.i32_ne ],
+          [ Opcodes.if, Blocktype.void ],
+          ...printStaticStr(', '),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
+
+          [ Opcodes.end ],
+
+          ...printStaticStr(' ]'),
+        ],
+        [TYPES.undefined]: [
+          ...printStaticStr('undefined')
+        ],
+        [TYPES.function]: [
+          ...printStaticStr('function () {}')
+        ],
+        [TYPES.object]: [
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.if, Blocktype.void ],
+          ...printStaticStr('{}'),
+          [ Opcodes.else ],
+          ...printStaticStr('null'),
+          [ Opcodes.end ]
+        ],
+        default: [
+          [ Opcodes.local_get, 0 ],
+          [ Opcodes.call, importedFuncs.print ],
+        ]
+      }, Blocktype.void),
+
       ...char('\n'),
       [ Opcodes.call, importedFuncs.printChar ]
     ]

package/compiler/codeGen.js

@@ -1,5 +1,5 @@
 import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from "./wasmSpec.js";
-import { ieee754_binary64, signedLEB128, unsignedLEB128 } from "./encoding.js";
+import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from "./encoding.js";
 import { operatorOpcode } from "./expression.js";
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from "./builtins.js";
 import { PrototypeFuncs } from "./prototype.js";
@@ -68,7 +68,12 @@ const generate = (scope, decl, global = false, name = undefined) => {
 
     case 'ArrowFunctionExpression':
     case 'FunctionDeclaration':
-      generateFunc(scope, decl);
+      const func = generateFunc(scope, decl);
+
+      if (decl.type.endsWith('Expression')) {
+        return number(func.index);
+      }
+
       return [];
 
     case 'BlockStatement':
@@ -214,6 +219,11 @@ const generate = (scope, decl, global = false, name = undefined) => {
     }
 
     default:
+      if (decl.type.startsWith('TS')) {
+        // ignore typescript nodes
+        return [];
+      }
+
       return todo(`no generation for ${decl.type}!`);
   }
 };
@@ -360,12 +370,12 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
       ...right,
       // note type
       ...rightType,
-      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+      setLastType(scope),
       [ Opcodes.else ],
       [ Opcodes.local_get, localTmp(scope, 'logictmpi', Valtype.i32) ],
       // note type
       ...leftType,
-      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+      setLastType(scope),
       [ Opcodes.end ],
       Opcodes.i32_from
     ];
@@ -379,12 +389,12 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
     ...right,
     // note type
     ...rightType,
-    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+    setLastType(scope),
     [ Opcodes.else ],
     [ Opcodes.local_get, localTmp(scope, 'logictmp') ],
     // note type
     ...leftType,
-    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+    setLastType(scope),
     [ Opcodes.end ]
   ];
 };
@@ -852,7 +862,16 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 
   let tmpLeft, tmpRight;
   // if equal op, check if strings for compareStrings
-  if (op === '===' || op === '==' || op === '!==' || op === '!=') {
+  if (op === '===' || op === '==' || op === '!==' || op === '!=') (() => {
+    const knownLeft = knownType(scope, leftType);
+    const knownRight = knownType(scope, rightType);
+
+    // todo: intelligent partial skip later
+    // if neither known are string, stop this madness
+    if ((knownLeft != null && knownLeft !== TYPES.string) && (knownRight != null && knownRight !== TYPES.string)) {
+      return;
+    }
+
     tmpLeft = localTmp(scope, '__tmpop_left');
     tmpRight = localTmp(scope, '__tmpop_right');
 
@@ -902,7 +921,7 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
       // endOut.push(stringOnly([ Opcodes.end ]));
       endOut.unshift(stringOnly([ Opcodes.end ]));
     // }
-  }
+  })();
 
   return finalise([
     ...left,
@@ -933,6 +952,18 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     locals[nameParam(i)] = { idx: i, type: allLocals[i] };
   }
 
+  if (typeof wasm === 'function') {
+    const scope = {
+      name,
+      params,
+      locals,
+      returns,
+      localInd: allLocals.length,
+    };
+
+    wasm = wasm(scope, { TYPES, typeSwitch, makeArray });
+  }
+
   let baseGlobalIdx, i = 0;
   for (const type of globalTypes) {
     if (baseGlobalIdx === undefined) baseGlobalIdx = globalInd;
@@ -1013,18 +1044,7 @@ const TYPES = {
 
   // these are not "typeof" types but tracked internally
   _array: 0x10,
-  _regexp: 0x11,
-
-  // typed arrays
-  _int8array: 0x20,
-  _uint8array: 0x21,
-  _uint8clampedarray: 0x22,
-  _int16array: 0x23,
-  _uint16array: 0x24,
-  _int32array: 0x25,
-  _uint32array: 0x26,
-  _float32array: 0x27,
-  _float64array: 0x28,
+  _regexp: 0x11
 };
 
 const TYPE_NAMES = {
@@ -1062,11 +1082,13 @@ const setType = (scope, _name, type) => {
 
   const out = typeof type === 'number' ? number(type, Valtype.i32) : type;
 
+  if (typedInput && scope.locals[name]?.metadata?.type != null) return [];
   if (scope.locals[name]) return [
     ...out,
     [ Opcodes.local_set, scope.locals[name + '#type'].idx ]
   ];
 
+  if (typedInput && globals[name]?.metadata?.type != null) return [];
   if (globals[name]) return [
     ...out,
     [ Opcodes.global_set, globals[name + '#type'].idx ]
@@ -1075,6 +1097,15 @@ const setType = (scope, _name, type) => {
   // throw new Error('could not find var');
 };
 
+const getLastType = scope => {
+  scope.gotLastType = true;
+  return [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ];
+};
+
+const setLastType = scope => {
+  return [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ];
+};
+
 const getNodeType = (scope, node) => {
   const inner = () => {
     if (node.type === 'Literal') {
@@ -1103,7 +1134,19 @@ const getNodeType = (scope, node) => {
       if (builtinFuncs[name]) return TYPES[builtinFuncs[name].returnType ?? 'number'];
       if (internalConstrs[name]) return internalConstrs[name].type;
 
-      if (scope.locals['#last_type']) return [ [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ] ];
+      // check if this is a prototype function
+      // if so and there is only one impl (eg charCodeAt)
+      // 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.values(prototypeFuncs).filter(x => x[func] != null);
+        if (protoFuncs.length === 1) return protoFuncs[0].returnType ?? TYPES.number;
+      }
+
+      if (scope.locals['#last_type']) return [ getLastType(scope) ];
 
       // presume
       // todo: warn here?
@@ -1188,7 +1231,7 @@ const getNodeType = (scope, node) => {
       return TYPES.number;
     }
 
-    if (scope.locals['#last_type']) return [ [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ] ];
+    if (scope.locals['#last_type']) return [ getLastType(scope) ];
 
     // presume
     // todo: warn here?
@@ -1201,6 +1244,23 @@ const getNodeType = (scope, node) => {
   return ret;
 };
 
+const toString = (scope, wasm, type) => {
+  const tmp = localTmp(scope, '#tostring_tmp');
+  return [
+    ...wasm,
+    [ Opcodes.local_set, tmp ],
+
+    ...typeSwitch(scope, type, {
+      [TYPES.string]: [
+        [ Opcodes.local_get, tmp ]
+      ],
+      [TYPES.undefined]: [
+        // [ Opcodes.]
+      ]
+    })
+  ]
+};
+
 const generateLiteral = (scope, decl, global, name) => {
   if (decl.value === null) return number(NULL);
 
@@ -1367,13 +1427,13 @@ const generateCall = (scope, decl, _global, _name) => {
       const finalStatement = parsed.body[parsed.body.length - 1];
       out.push(
         ...getNodeType(scope, finalStatement),
-        [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+        setLastType(scope)
       );
     } else if (countLeftover(out) === 0) {
       out.push(...number(UNDEFINED));
       out.push(
         ...number(TYPES.undefined, Valtype.i32),
-        [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+        setLastType(scope)
       );
     }
 
@@ -1391,8 +1451,7 @@ const generateCall = (scope, decl, _global, _name) => {
   if (name && name.startsWith('__')) {
     const spl = name.slice(2).split('_');
 
-    const func = spl[spl.length - 1];
-    protoName = func;
+    protoName = spl[spl.length - 1];
 
     target = { ...decl.callee };
     target.name = spl.slice(0, -1).join('_');
@@ -1418,12 +1477,11 @@ const generateCall = (scope, decl, _global, _name) => {
         Opcodes.i32_from_u,
 
         ...number(TYPES.boolean, Valtype.i32),
-        [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+        setLastType(scope)
       ];
     }
 
-    const func = decl.callee.property.name;
-    protoName = func;
+    protoName = decl.callee.property.name;
 
     target = decl.callee.object;
   }
@@ -1468,7 +1526,7 @@ const generateCall = (scope, decl, _global, _name) => {
             ...RTArrayUtil.getLength(getPointer),
 
             ...number(TYPES.number, Valtype.i32),
-            [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+            setLastType(scope)
           ];
           continue;
         }
@@ -1499,7 +1557,7 @@ const generateCall = (scope, decl, _global, _name) => {
           ...protoOut,
 
           ...number(protoFunc.returnType ?? TYPES.number, Valtype.i32),
-          [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+          setLastType(scope),
           [ Opcodes.end ]
         ];
       }
@@ -1567,7 +1625,9 @@ const generateCall = (scope, decl, _global, _name) => {
   const func = funcs.find(x => x.index === idx);
 
   const userFunc = (funcIndex[name] && !importedFuncs[name] && !builtinFuncs[name] && !internalConstrs[name]) || idx === -1;
-  const paramCount = func && (userFunc ? func.params.length / 2 : func.params.length);
+  const typedParams = userFunc || builtinFuncs[name]?.typedParams;
+  const typedReturn = userFunc || builtinFuncs[name]?.typedReturn;
+  const paramCount = func && (typedParams ? func.params.length / 2 : func.params.length);
 
   let args = decl.arguments;
   if (func && args.length < paramCount) {
@@ -1585,12 +1645,12 @@ const generateCall = (scope, decl, _global, _name) => {
   let out = [];
   for (const arg of args) {
     out = out.concat(generate(scope, arg));
-    if (userFunc) out = out.concat(getNodeType(scope, arg));
+    if (typedParams) out = out.concat(getNodeType(scope, arg));
   }
 
   out.push([ Opcodes.call, idx ]);
 
-  if (!userFunc) {
+  if (!typedReturn) {
     // let type;
     // if (builtinFuncs[name]) type = TYPES[builtinFuncs[name].returnType ?? 'number'];
     // if (internalConstrs[name]) type = internalConstrs[name].type;
@@ -1600,7 +1660,7 @@ const generateCall = (scope, decl, _global, _name) => {
     //   ...number(type, Valtype.i32),
     //   [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
     // );
-  } else out.push([ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]);
+  } else out.push(setLastType(scope));
 
   return out;
 };
@@ -1625,9 +1685,116 @@ const unhackName = name => {
   return name;
 };
 
+const knownType = (scope, type) => {
+  if (type.length === 1 && type[0][0] === Opcodes.i32_const) {
+    return type[0][1];
+  }
+
+  if (typedInput && type.length === 1 && type[0][0] === Opcodes.local_get) {
+    const idx = type[0][1];
+
+    // type idx = var idx + 1
+    const v = Object.values(scope.locals).find(x => x.idx === idx - 1);
+    if (v.metadata?.type != null) return v.metadata.type;
+  }
+
+  return null;
+};
+
+const brTable = (input, bc, returns) => {
+  const out = [];
+  const keys = Object.keys(bc);
+  const count = keys.length;
+
+  if (count === 1) {
+    // return [
+    //   ...input,
+    //   ...bc[keys[0]]
+    // ];
+    return bc[keys[0]];
+  }
+
+  if (count === 2) {
+    // just use if else
+    const other = keys.find(x => x !== 'default');
+    return [
+      ...input,
+      ...number(other, Valtype.i32),
+      [ Opcodes.i32_eq ],
+      [ Opcodes.if, returns ],
+      ...bc[other],
+      [ Opcodes.else ],
+      ...bc.default,
+      [ Opcodes.end ]
+    ];
+  }
+
+  for (let i = 0; i < count; i++) {
+    if (i === 0) out.push([ Opcodes.block, returns, 'br table start' ]);
+      else out.push([ Opcodes.block, Blocktype.void ]);
+  }
+
+  const nums = keys.filter(x => +x);
+  const offset = Math.min(...nums);
+  const max = Math.max(...nums);
+
+  const table = [];
+  let br = 1;
+
+  for (let i = offset; i <= max; i++) {
+    // if branch for this num, go to that block
+    if (bc[i]) {
+      table.push(br);
+      br++;
+      continue;
+    }
+
+    // else default
+    table.push(0);
+  }
+
+  out.push(
+    [ Opcodes.block, Blocktype.void ],
+    ...input,
+    ...(offset > 0 ? [
+      ...number(offset, Valtype.i32),
+      [ Opcodes.i32_sub ]
+    ] : []),
+    [ Opcodes.br_table, ...encodeVector(table), 0 ]
+  );
+
+  // if you can guess why we sort the wrong way and then reverse
+  // (instead of just sorting the correct way)
+  // dm me and if you are correct and the first person
+  // I will somehow shout you out or something
+  const orderedBc = keys.sort((a, b) => b - a).reverse();
+
+  br = count - 1;
+  for (const x of orderedBc) {
+    out.push(
+      [ Opcodes.end ],
+      ...bc[x],
+      ...(br === 0 ? [] : [ [ Opcodes.br, br ] ])
+    );
+    br--;
+  }
+
+  return [
+    ...out,
+    [ Opcodes.end, 'br table end' ]
+  ];
+};
+
 const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
-  const tmp = localTmp(scope, '#typeswitch_tmp', Valtype.i32);
+  const known = knownType(scope, type);
+  if (known != null) {
+    return bc[known] ?? bc.default;
+  }
+
+  if (process.argv.includes('-typeswitch-use-brtable'))
+    return brTable(type, bc, returns);
 
+  const tmp = localTmp(scope, '#typeswitch_tmp', Valtype.i32);
   const out = [
     ...type,
     [ Opcodes.local_set, tmp ],
@@ -1679,6 +1846,49 @@ const allocVar = (scope, name, global = false) => {
   return idx;
 };
 
+const addVarMetadata = (scope, name, global = false, metadata = {}) => {
+  const target = global ? globals : scope.locals;
+
+  target[name].metadata ??= {};
+  for (const x in metadata) {
+    if (metadata[x] != null) target[name].metadata[x] = metadata[x];
+  }
+};
+
+const typeAnnoToPorfType = x => {
+  if (TYPES[x]) return TYPES[x];
+  if (TYPES['_' + x]) return TYPES['_' + x];
+
+  switch (x) {
+    case 'i32':
+      return TYPES.number;
+  }
+
+  return null;
+};
+
+const extractTypeAnnotation = decl => {
+  let a = decl;
+  while (a.typeAnnotation) a = a.typeAnnotation;
+
+  let type, elementType;
+  if (a.typeName) {
+    type = a.typeName.name;
+  } else if (a.type.endsWith('Keyword')) {
+    type = a.type.slice(2, -7).toLowerCase();
+  } else if (a.type === 'TSArrayType') {
+    type = 'array';
+    elementType = extractTypeAnnotation(a.elementType).type;
+  }
+
+  const typeName = type;
+  type = typeAnnoToPorfType(type);
+
+  // if (decl.name) console.log(decl.name, { type, elementType });
+
+  return { type, typeName, elementType };
+};
+
 const generateVar = (scope, decl) => {
   let out = [];
 
@@ -1706,6 +1916,11 @@ const generateVar = (scope, decl) => {
     }
 
     let idx = allocVar(scope, name, global);
+
+    if (typedInput && x.id.typeAnnotation) {
+      addVarMetadata(scope, name, global, extractTypeAnnotation(x.id));
+    }
+
     if (x.init) {
       out = out.concat(generate(scope, x.init, global, name));
 
@@ -1869,7 +2084,7 @@ const generateAssign = (scope, decl) => {
       ], getType(scope, name), getNodeType(scope, decl.right), isGlobal, name, true),
       [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
 
-      [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ],
+      getLastType(scope),
       // hack: type is idx+1
       [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx + 1 ],
     ];
@@ -2036,7 +2251,7 @@ const generateConditional = (scope, decl) => {
   // note type
   out.push(
     ...getNodeType(scope, decl.consequent),
-    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+    setLastType(scope)
   );
 
   out.push([ Opcodes.else ]);
@@ -2045,7 +2260,7 @@ const generateConditional = (scope, decl) => {
   // note type
   out.push(
     ...getNodeType(scope, decl.alternate),
-    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+    setLastType(scope)
   );
 
   out.push([ Opcodes.end ]);
@@ -2489,7 +2704,7 @@ export const generateMember = (scope, decl, _global, _name) => {
 
   // // todo: we should only do this for strings but we don't know at compile-time :(
   // hack: this is naughty and will break things!
-  let newOut = number(0, Valtype.f64), newPointer = -1;
+  let newOut = number(0, valtypeBinary), newPointer = -1;
   if (pages.hasString) {
     0, [ newOut, newPointer ] = makeArray(scope, {
       rawElements: new Array(1)
@@ -2516,7 +2731,7 @@ export const generateMember = (scope, decl, _global, _name) => {
       [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
       ...number(TYPES.number, Valtype.i32),
-      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+      setLastType(scope)
     ],
 
     [TYPES.string]: [
@@ -2548,7 +2763,7 @@ export const generateMember = (scope, decl, _global, _name) => {
       ...number(newPointer),
 
       ...number(TYPES.string, Valtype.i32),
-      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+      setLastType(scope)
     ],
 
     default: [ [ Opcodes.unreachable ] ]
@@ -2597,7 +2812,7 @@ const generateFunc = (scope, decl) => {
   if (decl.generator) return todo('generator functions are not supported');
 
   const name = decl.id ? decl.id.name : `anonymous_${randId()}`;
-  const params = decl.params?.map(x => x.name) ?? [];
+  const params = decl.params ?? [];
 
   // const innerScope = { ...scope };
   // TODO: share scope/locals between !!!
@@ -2611,7 +2826,11 @@ const generateFunc = (scope, decl) => {
   };
 
   for (let i = 0; i < params.length; i++) {
-    allocVar(innerScope, params[i], false);
+    allocVar(innerScope, params[i].name, false);
+
+    if (typedInput && params[i].typeAnnotation) {
+      addVarMetadata(innerScope, params[i].name, false, extractTypeAnnotation(params[i]));
+    }
   }
 
   let body = objectHack(decl.body);
@@ -2650,117 +2869,6 @@ const generateFunc = (scope, decl) => {
     );
   }
 
-  // change v128 params into many <type> (i32x4 -> i32/etc) instead as unsupported param valtype
-  let offset = 0, vecParams = 0;
-  for (let i = 0; i < params.length; i++) {
-    const name = params[i];
-    const local = func.locals[name];
-    if (local.type === Valtype.v128) {
-      vecParams++;
-
-      /* wasm.unshift( // add v128 load for param
-        [ Opcodes.i32_const, 0 ],
-        [ ...Opcodes.v128_load, 0, i * 16 ],
-        [ Opcodes.local_set, local.idx ]
-      ); */
-
-      // using params and replace_lane is noticably faster than just loading from memory (above) somehow
-
-      // extract valtype and lane count from vec type (i32x4 = i32 4, i8x16 = i8 16, etc)
-      const { vecType } = local;
-      let [ type, lanes ] = vecType.split('x');
-      if (!type || !lanes) throw new Error('bad metadata from vec params'); // sanity check
-
-      lanes = parseInt(lanes);
-      type = Valtype[type];
-
-      const name = params[i]; // get original param name
-
-      func.params.splice(offset, 1, ...new Array(lanes).fill(type)); // add new params of {type}, {lanes} times
-
-      // update index of original local
-      // delete func.locals[name];
-
-      // add new locals for params
-      for (let j = 0; j < lanes; j++) {
-        func.locals[name + j] = { idx: offset + j, type, vecParamAutogen: true };
-      }
-
-      // prepend wasm to generate expected v128 locals
-      wasm.splice(i * 2 + offset * 2, 0,
-        ...i32x4(0, 0, 0, 0),
-        ...new Array(lanes).fill(0).flatMap((_, j) => [
-          [ Opcodes.local_get, offset + j ],
-          [ ...Opcodes[vecType + '_replace_lane'], j ]
-        ]),
-        [ Opcodes.local_set, i ]
-      );
-
-      offset += lanes;
-
-      // note: wrapping is disabled for now due to perf/dx concerns (so this will never run)
-      /* if (!func.name.startsWith('#')) func.name = '##' + func.name;
-
-      // add vec type index to hash name prefix for wrapper to know how to wrap
-      const vecTypeIdx = [ 'i8x16', 'i16x8', 'i32x4', 'i64x2', 'f32x4', 'f64x2' ].indexOf(local.vecType);
-      const secondHash = func.name.slice(1).indexOf('#');
-      func.name = '#' + func.name.slice(1, secondHash) + vecTypeIdx + func.name.slice(secondHash); */
-    }
-  }
-
-  if (offset !== 0) {
-    // bump local indexes for all other locals after
-    for (const x in func.locals) {
-      const local = func.locals[x];
-      if (!local.vecParamAutogen) local.idx += offset;
-    }
-
-    // bump local indexes in wasm local.get/set
-    for (let j = 0; j < wasm.length; j++) {
-      const inst = wasm[j];
-      if (j < offset * 2 + vecParams * 2) {
-        if (inst[0] === Opcodes.local_set) inst[1] += offset;
-        continue;
-      }
-
-      if (inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set) inst[1] += offset;
-    }
-  }
-
-  // change v128 return into many <type> instead as unsupported return valtype
-  const lastReturnLocal = wasm.length > 2 && wasm[wasm.length - 1][0] === Opcodes.return && Object.values(func.locals).find(x => x.idx === wasm[wasm.length - 2][1]);
-  if (lastReturnLocal && lastReturnLocal.type === Valtype.v128) {
-    const name = Object.keys(func.locals)[Object.values(func.locals).indexOf(lastReturnLocal)];
-    // extract valtype and lane count from vec type (i32x4 = i32 4, i8x16 = i8 16, etc)
-    const { vecType } = lastReturnLocal;
-    let [ type, lanes ] = vecType.split('x');
-    if (!type || !lanes) throw new Error('bad metadata from vec params'); // sanity check
-
-    lanes = parseInt(lanes);
-    type = Valtype[type];
-
-    const vecIdx = lastReturnLocal.idx;
-
-    const lastIdx = Math.max(0, ...Object.values(func.locals).map(x => x.idx));
-    const tmpIdx = [];
-    for (let i = 0; i < lanes; i++) {
-      const idx = lastIdx + i + 1;
-      tmpIdx.push(idx);
-      func.locals[name + i] = { idx, type, vecReturnAutogen: true };
-    }
-
-    wasm.splice(wasm.length - 1, 1,
-      ...new Array(lanes).fill(0).flatMap((_, i) => [
-        i === 0 ? null : [ Opcodes.local_get, vecIdx ],
-        [ ...Opcodes[vecType + '_extract_lane'], i ],
-        [ Opcodes.local_set, tmpIdx[i] ],
-      ].filter(x => x !== null)),
-      ...new Array(lanes).fill(0).map((_, i) => [ Opcodes.local_get, tmpIdx[i]])
-    );
-
-    func.returns = new Array(lanes).fill(type);
-  }
-
   func.wasm = wasm;
 
   funcs.push(func);

package/compiler/decompile.js

@@ -15,7 +15,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
   if (name) out += `${makeSignature(params, returns)} ;; $${name} (${ind})\n`;
 
   const justLocals = Object.values(locals).sort((a, b) => a.idx - b.idx).slice(params.length);
-  if (justLocals.length > 0) out += `  local ${justLocals.map(x => invValtype[x.type]).join(' ')}\n`;
+  if (name && justLocals.length > 0) out += `  local ${justLocals.map(x => invValtype[x.type]).join(' ')}\n`;
 
   let i = -1, lastInst;
   let byte = 0;
@@ -32,7 +32,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       inst = [ [ inst[0], inst[1] ], ...inst.slice(2) ];
     }
 
-    if (inst[0] === Opcodes.end || inst[0] === Opcodes.else || inst[0] === Opcodes.catch_all) depth--;
+    if (depth > 0 && (inst[0] === Opcodes.end || inst[0] === Opcodes.else || inst[0] === Opcodes.catch_all)) depth--;
 
     out += ' '.repeat(Math.max(0, depth * 2));
 
@@ -119,7 +119,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
 export const highlightAsm = asm => asm
   .replace(/(local|global|memory)\.[^\s]*/g, _ => `\x1B[31m${_}\x1B[0m`)
   .replace(/(i(8|16|32|64)x[0-9]+|v128)(\.[^\s]*)?/g, _ => `\x1B[34m${_}\x1B[0m`)
-  .replace(/[^m](i32|i64|f32|f64|drop)(\.[^\s]*)?/g, _ => `${_[0]}\x1B[36m${_.slice(1)}\x1B[0m`)
+  .replace(/(i32|i64|f32|f64|drop)(\.[^\s]*)?/g, _ => `\x1B[36m${_}\x1B[0m`)
   .replace(/(return_call|call|br_if|br|return|rethrow|throw)/g, _ => `\x1B[35m${_}\x1B[0m`)
   .replace(/(block|loop|if|end|else|try|catch_all|catch|delegate)/g, _ => `\x1B[95m${_}\x1B[0m`)
   .replace(/unreachable/g, _ => `\x1B[91m${_}\x1B[0m`)

package/compiler/index.js

@@ -52,7 +52,7 @@ export default (code, flags) => {
   if (process.argv.includes('-funcs')) logFuncs(funcs, globals, exceptions);
 
   const t2 = performance.now();
-  opt(funcs, globals, pages);
+  opt(funcs, globals, pages, tags);
   if (flags.includes('info')) console.log(`3. optimized code in ${(performance.now() - t2).toFixed(2)}ms`);
 
   if (process.argv.includes('-opt-funcs')) logFuncs(funcs, globals, exceptions);

package/compiler/opt.js

@@ -11,7 +11,7 @@ const performWasmOp = (op, a, b) => {
   }
 };
 
-export default (funcs, globals, pages) => {
+export default (funcs, globals, pages, tags) => {
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
   if (optLevel === 0) return;
 
@@ -99,10 +99,14 @@ export default (funcs, globals, pages) => {
 
   if (process.argv.includes('-opt-inline-only')) return;
 
+  const tagUse = tags.reduce((acc, x) => { acc[x.idx] = 0; return acc; }, {});
+
   // wasm transform pass
   for (const f of funcs) {
     const wasm = f.wasm;
 
+    const lastType = f.locals['#last_type'];
+
     let runs = 2; // how many by default? add arg?
     while (runs > 0) {
       runs--;
@@ -125,6 +129,8 @@ export default (funcs, globals, pages) => {
         if (inst[0] === Opcodes.local_get) getCount[inst[1]]++;
         if (inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) setCount[inst[1]]++;
 
+        if (inst[0] === Opcodes.throw) tagUse[inst[1]]++;
+
         if (inst[0] === Opcodes.block) {
           // remove unneeded blocks (no brs inside)
           // block
@@ -141,7 +147,7 @@ export default (funcs, globals, pages) => {
               depth--;
               if (depth <= 0) break;
             }
-            if (op === Opcodes.br || op === Opcodes.br_if) {
+            if (op === Opcodes.br || op === Opcodes.br_if || op === Opcodes.br_table) {
               hasBranch = true;
               break;
             }
@@ -221,6 +227,7 @@ export default (funcs, globals, pages) => {
           }
 
           if (checks === 0) {
+            // todo: review indexes below
             wasm.splice(j - 1, 2, [ Opcodes.drop ]); // remove typeswitch start
             wasm.splice(i - 1, 1); // remove this inst
 
@@ -231,6 +238,13 @@ export default (funcs, globals, pages) => {
           }
         }
 
+        // remove setting last type if it is never gotten
+        if (!f.gotLastType && inst[0] === Opcodes.local_set && inst[1] === lastType?.idx) {
+          // replace this inst with drop
+          wasm.splice(i, 1, [ Opcodes.drop ]); // remove this and last inst
+          if (i > 0) i--;
+        }
+
         if (i < 1) continue;
         let lastInst = wasm[i - 1];
 
@@ -531,5 +545,12 @@ export default (funcs, globals, pages) => {
     }
   }
 
+  for (const x in tagUse) {
+    if (tagUse[x] === 0) {
+      const el = tags.find(y => y.idx === x);
+      tags.splice(tags.indexOf(el), 1);
+    }
+  }
+
   // return funcs;
 };

package/compiler/parse.js

@@ -1,4 +1,5 @@
 import { log } from "./log.js";
+// import { parse } from 'acorn';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -6,16 +7,9 @@ if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
   globalThis.process = { argv: ['', '', ...Deno.args], stdout: { write: str => Deno.writeAllSync(Deno.stdout, textEncoder.encode(str)) } };
 }
 
-// import { parse } from 'acorn';
-
-let parser, parse;
-
-const loadParser = async () => {
-  parser = process.argv.find(x => x.startsWith('-parser='))?.split('=')?.[1] ?? 'acorn';
-  0, { parse } = (await import((globalThis.document ? 'https://esm.sh/' : '') + parser));
-};
-globalThis._porf_loadParser = loadParser;
-await loadParser();
+// should we try to support types (while parsing)
+const types = process.argv.includes('-parse-types');
+globalThis.typedInput = types && process.argv.includes('-opt-types');
 
 // todo: review which to use by default
 // supported parsers:
@@ -24,8 +18,13 @@ await loadParser();
 // - hermes-parser
 // - @babel/parser
 
-// should we try to support types (while parsing)
-const types = process.argv.includes('-types');
+let parser, parse;
+const loadParser = async (fallbackParser = 'acorn', forceParser) => {
+  parser = forceParser ?? process.argv.find(x => x.startsWith('-parser='))?.split('=')?.[1] ?? fallbackParser;
+  0, { parse } = (await import((globalThis.document ? 'https://esm.sh/' : '') + parser));
+};
+globalThis._porf_loadParser = loadParser;
+await loadParser(types ? '@babel/parser' : undefined);
 
 if (types && !['@babel/parser', 'hermes-parser'].includes(parser)) log.warning('parser', `passed -types with a parser (${parser}) which does not support`);
 

package/compiler/sections.js

@@ -150,7 +150,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
       if (typeCount !== 0) localDecl.push(encodeLocal(typeCount, lastType));
 
-      return encodeVector([ ...encodeVector(localDecl), ...x.wasm.flat().filter(x => x <= 0xff), Opcodes.end ]);
+      return encodeVector([ ...encodeVector(localDecl), ...x.wasm.flat().filter(x => x != null && x <= 0xff), Opcodes.end ]);
     }))
   );
 

package/compiler/wasmSpec.js

@@ -32,8 +32,6 @@ export const Opcodes = {
   throw: 0x08,
   rethrow: 0x09,
 
-  return: 0x0F,
-
   call: 0x10,
   call_indirect: 0x11,
   return_call: 0x12,
@@ -42,7 +40,10 @@ export const Opcodes = {
   end: 0x0b,
   br: 0x0c,
   br_if: 0x0d,
+  br_table: 0x0e,
+  return: 0x0f,
   call: 0x10,
+
   drop: 0x1a,
 
   local_get: 0x20,

package/compiler/wrap.js

@@ -1,5 +1,6 @@
 import compile from './index.js';
 import decompile from './decompile.js';
+import { encodeVector, encodeLocal } from './encoding.js';
 // import fs from 'node:fs';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
@@ -35,14 +36,95 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
   if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
   const t2 = performance.now();
-  const { instance } = await WebAssembly.instantiate(wasm, {
-    '': {
-      p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
-      c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
-      t: _ => performance.now(),
-      ...customImports
+
+  let instance;
+  try {
+    0, { instance } = await WebAssembly.instantiate(wasm, {
+      '': {
+        p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
+        c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
+        t: _ => performance.now(),
+        ...customImports
+      }
+    });
+  } catch (e) {
+    const funcInd = parseInt(e.message.match(/function #([0-9]+) /)[1]);
+    const blobOffset = parseInt(e.message.split('@')[1]);
+
+    // convert blob offset -> function wasm offset.
+    // this is not good code and is somewhat duplicated
+    // I just want it to work for debugging, I don't care about perf/yes
+
+    const func = funcs.find(x => x.index === funcInd);
+    const locals = Object.values(func.locals).sort((a, b) => a.idx - b.idx).slice(func.params.length).sort((a, b) => a.idx - b.idx);
+
+    let localDecl = [], typeCount = 0, lastType;
+    for (let i = 0; i < locals.length; i++) {
+      const local = locals[i];
+      if (i !== 0 && local.type !== lastType) {
+        localDecl.push(encodeLocal(typeCount, lastType));
+        typeCount = 0;
+      }
+
+      typeCount++;
+      lastType = local.type;
+    }
+
+    if (typeCount !== 0) localDecl.push(encodeLocal(typeCount, lastType));
+
+    const toFind = encodeVector(localDecl).concat(func.wasm.flat().filter(x => x != null && x <= 0xff).slice(0, 40));
+
+    let i = 0;
+    for (; i < wasm.length; i++) {
+      let mismatch = false;
+      for (let j = 0; j < toFind.length; j++) {
+        if (wasm[i + j] !== toFind[j]) {
+          mismatch = true;
+          break;
+        }
+      }
+
+      if (!mismatch) break;
     }
-  });
+
+    if (i === wasm.length) throw e;
+
+    const offset = (blobOffset - i) + encodeVector(localDecl).length;
+
+    let cumLen = 0;
+    i = 0;
+    for (; i < func.wasm.length; i++) {
+      cumLen += func.wasm[i].filter(x => x != null && x <= 0xff).length;
+      if (cumLen === offset) break;
+    }
+
+    if (cumLen !== offset) throw e;
+
+    i -= 1;
+
+    console.log(`\x1B[35m\x1B[1mporffor backtrace\u001b[0m`);
+
+    console.log('\x1B[4m' + func.name + '\x1B[0m');
+
+    const surrounding = 6;
+
+    const decomp = decompile(func.wasm.slice(i - surrounding, i + surrounding + 1), '', 0, func.locals, func.params, func.returns, funcs, globals, exceptions).slice(0, -1).split('\n');
+
+    const noAnsi = s => s.replace(/\u001b\[[0-9]+m/g, '');
+    let longest = 0;
+    for (let j = 0; j < decomp.length; j++) {
+      longest = Math.max(longest, noAnsi(decomp[j]).length);
+    }
+
+    const middle = Math.floor(decomp.length / 2);
+    decomp[middle] = `\x1B[47m\x1B[30m${noAnsi(decomp[middle])}${'\u00a0'.repeat(longest - noAnsi(decomp[middle]).length)}\x1B[0m`;
+
+    console.log('\x1B[90m...\x1B[0m');
+    console.log(decomp.join('\n'));
+    console.log('\x1B[90m...\x1B[0m\n');
+
+    throw e;
+  }
 
   times.push(performance.now() - t2);
   if (flags.includes('info')) console.log(`instantiated in ${times[1].toFixed(2)}ms`);

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.2.0-9ca9aed",
+  "version": "0.2.0-aea77ff",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/runner/repl.js

@@ -45,9 +45,9 @@ let prev = '';
 const run = async (source, _context, _filename, callback, run = true) => {
   // hack: print "secret" before latest code ran to only enable printing for new code
 
-  let toRun = prev + `;\nprint(-0x1337);\n` + source.trim();
+  let toRun = (prev ? (prev + `;\nprint(-0x1337);\n`) : '') + source.trim();
 
-  let shouldPrint = false;
+  let shouldPrint = !prev;
   const { exports, wasm, pages } = await compile(toRun, [], {}, str => {
     if (shouldPrint) process.stdout.write(str);
     if (str === '-4919') shouldPrint = true;

package/tmp.c

@@ -1,71 +0,0 @@
-
-#include <stdio.h>
-
-struct ReturnValue {
-  double value;
-  long type;
-};
-
-double sum = 0;
-long sumdtype = 0;
-double counter = 0;
-long counterdtype = 0;
-
-double inline f64_f(double x, double y) {
-  return (x - ((int)(x / y) * y));
-}
-
-struct ReturnValue isPrime(double number, long numberdtype) {
-  double i = 0;
-  long idtype = 0;
-  double __tmpop_left = 0;
-  double __tmpop_right = 0;
-  long compare_left_pointer = 0;
-  long compare_left_length = 0;
-  long compare_right_pointer = 0;
-  long compare_right_length = 0;
-  long compare_index = 0;
-  long compare_index_end = 0;
-
-  if (number < 2e+0) {
-    return (struct ReturnValue){ 1, 0e+0 };
-  }
-  i = 2e+0;
-  idtype = 0;
-  while (i < number) {
-    if (f64_f(number, i) == 0e+0) {
-      return (struct ReturnValue){ 1, 0e+0 };
-    }
-    i = i + 1e+0;
-  }
-  return (struct ReturnValue){ 1, 1e+0 };
-}
-
-double inline __console_log(double x) {
-  printf("%f\n", x);
-  printf("%c", (int)(1e+1));
-}
-
-int main() {
-  long dlast_type = 0;
-  double elogicinner_tmp = 0;
-  long dtypeswitch_tmp = 0;
-
-  sum = 0e+0;
-  sumdtype = 0;
-  counter = 0e+0;
-  counterdtype = 0;
-  while (counter <= 1e+5) {
-    const struct ReturnValue _ = isPrime(counter, counterdtype);
-    dlast_type = _.type;
-    if ((unsigned long)(elogicinner_tmp = _.value) == 1e+0) {
-      sum = sum + counter;
-      sumdtype = 0;
-    }
-    counter = counter + 1e+0;
-  }
-  __console_log(sum);
-
-  return 0;
-}
-