porffor 0.1.0 → 0.2.0-3fad637

package/compiler/codeGen.js

@@ -1,10 +1,12 @@
 import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from "./wasmSpec.js";
-import { signedLEB128, unsignedLEB128 } from "./encoding.js";
+import { ieee754_binary64, signedLEB128, unsignedLEB128 } from "./encoding.js";
 import { operatorOpcode } from "./expression.js";
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from "./builtins.js";
 import { PrototypeFuncs } from "./prototype.js";
-import { number, i32x4 } from "./embedding.js";
+import { number, i32x4, enforceOneByte, enforceTwoBytes, enforceFourBytes, enforceEightBytes } from "./embedding.js";
+import { log } from "./log.js";
 import parse from "./parse.js";
+import * as Rhemyn from "../rhemyn/compile.js";
 
 let globals = {};
 let globalInd = 0;
@@ -35,7 +37,14 @@ const debug = str => {
 };
 
 const todo = msg => {
-  throw new Error(`todo: ${msg}`);
+  class TodoError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = 'TodoError';
+    }
+  }
+
+  throw new TodoError(`todo: ${msg}`);
 
   const code = [];
 
@@ -101,6 +110,9 @@ const generate = (scope, decl, global = false, name = undefined) => {
     case 'WhileStatement':
       return generateWhile(scope, decl);
 
+    case 'ForOfStatement':
+      return generateForOf(scope, decl);
+
     case 'BreakStatement':
       return generateBreak(scope, decl);
 
@@ -141,45 +153,65 @@ const generate = (scope, decl, global = false, name = undefined) => {
 
       return [];
 
-    case 'TaggedTemplateExpression':
-      // hack for inline asm
-      if (decl.tag.name !== 'asm') return todo('tagged template expressions not implemented');
+    case 'TaggedTemplateExpression': {
+      const funcs = {
+        asm: str => {
+          let out = [];
 
-      const str = decl.quasi.quasis[0].value.raw;
-      let out = [];
+          for (const line of str.split('\n')) {
+            const asm = line.trim().split(';;')[0].split(' ');
+            if (asm[0] === '') continue; // blank
 
-      for (const line of str.split('\n')) {
-        const asm = line.trim().split(';;')[0].split(' ');
-        if (asm[0] === '') continue; // blank
+            if (asm[0] === 'local') {
+              const [ name, idx, type ] = asm.slice(1);
+              scope.locals[name] = { idx: parseInt(idx), type: Valtype[type] };
+              continue;
+            }
 
-        if (asm[0] === 'local') {
-          const [ name, idx, type ] = asm.slice(1);
-          scope.locals[name] = { idx: parseInt(idx), type: Valtype[type] };
-          continue;
-        }
+            if (asm[0] === 'returns') {
+              scope.returns = asm.slice(1).map(x => Valtype[x]);
+              continue;
+            }
 
-        if (asm[0] === 'returns') {
-          scope.returns = asm.slice(1).map(x => Valtype[x]);
-          continue;
-        }
+            if (asm[0] === 'memory') {
+              allocPage('asm instrinsic');
+              // todo: add to store/load offset insts
+              continue;
+            }
 
-        if (asm[0] === 'memory') {
-          scope.memory = true;
-          allocPage('asm instrinsic');
-          // todo: add to store/load offset insts
-          continue;
-        }
+            let inst = Opcodes[asm[0].replace('.', '_')];
+            if (!inst) throw new Error(`inline asm: inst ${asm[0]} not found`);
+
+            if (!Array.isArray(inst)) inst = [ inst ];
+            const immediates = asm.slice(1).map(x => parseInt(x));
+
+            out.push([ ...inst, ...immediates ]);
+          }
+
+          return out;
+        },
 
-        let inst = Opcodes[asm[0].replace('.', '_')];
-        if (!inst) throw new Error(`inline asm: inst ${asm[0]} not found`);
+        __internal_print_type: str => {
+          const type = getType(scope, str) - TYPES.number;
 
-        if (!Array.isArray(inst)) inst = [ inst ];
-        const immediates = asm.slice(1).map(x => parseInt(x));
+          return [
+            ...number(type),
+            [ Opcodes.call, importedFuncs.print ],
 
-        out.push([ ...inst, ...immediates ]);
+            // newline
+            ...number(10),
+            [ Opcodes.call, importedFuncs.printChar ]
+          ];
+        }
       }
 
-      return out;
+      const name = decl.tag.name;
+      // hack for inline asm
+      if (!funcs[name]) return todo('tagged template expressions not implemented');
+
+      const str = decl.quasi.quasis[0].value.raw;
+      return funcs[name](str);
+    }
 
     default:
       return todo(`no generation for ${decl.type}!`);
@@ -269,19 +301,17 @@ const generateIdent = (scope, decl) => {
 
 const generateReturn = (scope, decl) => {
   if (decl.argument === null) {
-    if (!scope.returnType) scope.returnType = TYPES.undefined;
-
     // just bare "return"
     return [
       ...number(UNDEFINED), // "undefined" if func returns
+      ...number(TYPES.undefined, Valtype.i32), // type undefined
       [ Opcodes.return ]
     ];
   }
 
-  if (!scope.returnType) scope.returnType = getNodeType(scope, decl.argument);
-
   return [
     ...generate(scope, decl.argument),
+    ...getNodeType(scope, decl.argument),
     [ Opcodes.return ]
   ];
 };
@@ -295,11 +325,13 @@ const localTmp = (scope, name, type = valtypeBinary) => {
   return idx;
 };
 
-const performLogicOp = (scope, op, left, right) => {
+const isIntOp = op => op && (op[0] >= 0xb7 && op[0] <= 0xba);
+
+const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   const checks = {
-    '||': Opcodes.eqz,
-    '&&': [ Opcodes.i32_to ]
-    // todo: ??
+    '||': falsy,
+    '&&': truthy,
+    '??': nullish
   };
 
   if (!checks[op]) return todo(`logic operator ${op} not implemented yet`);
@@ -307,14 +339,52 @@ const performLogicOp = (scope, op, left, right) => {
   // generic structure for {a} OP {b}
   // -->
   // _ = {a}; if (OP_CHECK) {b} else _
+
+  // if we can, use int tmp and convert at the end to help prevent unneeded conversions
+  // (like if we are in an if condition - very common)
+  const leftIsInt = isIntOp(left[left.length - 1]);
+  const rightIsInt = isIntOp(right[right.length - 1]);
+
+  const canInt = leftIsInt && rightIsInt;
+
+  if (canInt) {
+    // remove int -> float conversions from left and right
+    left.pop();
+    right.pop();
+
+    return [
+      ...left,
+      [ Opcodes.local_tee, localTmp(scope, 'logictmpi', Valtype.i32) ],
+      ...checks[op](scope, [], leftType, true, true),
+      [ Opcodes.if, Valtype.i32 ],
+      ...right,
+      // note type
+      ...rightType,
+      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+      [ Opcodes.else ],
+      [ Opcodes.local_get, localTmp(scope, 'logictmpi', Valtype.i32) ],
+      // note type
+      ...leftType,
+      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+      [ Opcodes.end ],
+      Opcodes.i32_from
+    ];
+  }
+
   return [
     ...left,
     [ Opcodes.local_tee, localTmp(scope, 'logictmp') ],
-    ...checks[op],
+    ...checks[op](scope, [], leftType, false, true),
     [ Opcodes.if, valtypeBinary ],
     ...right,
+    // note type
+    ...rightType,
+    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
     [ Opcodes.else ],
     [ Opcodes.local_get, localTmp(scope, 'logictmp') ],
+    // note type
+    ...leftType,
+    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
     [ Opcodes.end ]
   ];
 };
@@ -325,15 +395,16 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   // todo: optimize by looking up names in arrays and using that if exists?
   // todo: optimize this if using literals/known lengths?
 
-  scope.memory = true;
-
-  const pointer = arrays.get(name ?? '$undeclared');
-
   const rightPointer = localTmp(scope, 'concat_right_pointer', Valtype.i32);
   const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
   const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
 
+  const aotWFA = process.argv.includes('-aot-well-formed-string-approximation');
+  if (aotWFA) addVarMeta(name, { wellFormed: undefined });
+
   if (assign) {
+    const pointer = arrays.get(name ?? '$undeclared');
+
     return [
       // setup right
       ...right,
@@ -384,15 +455,12 @@ const concatStrings = (scope, left, right, global, name, assign) => {
 
   const leftPointer = localTmp(scope, 'concat_left_pointer', Valtype.i32);
 
-  const newOut = makeArray(scope, {
+  // alloc/assign array
+  const [ , pointer ] = makeArray(scope, {
     rawElements: new Array(0)
   }, global, name, true, 'i16');
 
   return [
-    // setup new/out array
-    ...newOut,
-    [ Opcodes.drop ],
-
     // setup left
     ...left,
     Opcodes.i32_to_u,
@@ -458,90 +526,309 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   ];
 };
 
-const falsy = (scope, wasm, type) => {
-  // arrays are always truthy
-  if (type === TYPES._array) return [
-    ...wasm,
-    [ Opcodes.drop ],
-    number(0)
-  ];
-
-  if (type === TYPES.string) {
-    // if "" (length = 0)
-    return [
-      // pointer
-      ...wasm,
+const compareStrings = (scope, left, right) => {
+  // todo: this should be rewritten into a func
+  // todo: convert left and right to strings if not
+  // todo: optimize by looking up names in arrays and using that if exists?
+  // todo: optimize this if using literals/known lengths?
 
-      // get length
-      [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+  const leftPointer = localTmp(scope, 'compare_left_pointer', Valtype.i32);
+  const leftLength = localTmp(scope, 'compare_left_length', Valtype.i32);
+  const rightPointer = localTmp(scope, 'compare_right_pointer', Valtype.i32);
+  const rightLength = localTmp(scope, 'compare_right_length', Valtype.i32);
 
-      // if length == 0
-      [ Opcodes.i32_eqz ],
-      Opcodes.i32_from_u
-    ]
-  }
+  const index = localTmp(scope, 'compare_index', Valtype.i32);
+  const indexEnd = localTmp(scope, 'compare_index_end', Valtype.i32);
 
-  // if = 0
   return [
-    ...wasm,
+    // setup left
+    ...left,
+    Opcodes.i32_to_u,
+    [ Opcodes.local_tee, leftPointer ],
 
-    ...Opcodes.eqz,
-    Opcodes.i32_from_u
+    // setup right
+    ...right,
+    Opcodes.i32_to_u,
+    [ Opcodes.local_tee, rightPointer ],
+
+    // fast path: check leftPointer == rightPointer
+    // use if (block) for everything after to "return" a value early
+    [ Opcodes.i32_ne ],
+    [ Opcodes.if, Valtype.i32 ],
+
+    // get lengths
+    [ Opcodes.local_get, leftPointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.local_tee, leftLength ],
+
+    [ Opcodes.local_get, rightPointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.local_tee, rightLength ],
+
+    // fast path: check leftLength != rightLength
+    [ Opcodes.i32_ne ],
+    [ Opcodes.if, Blocktype.void ],
+    ...number(0, Valtype.i32),
+    [ Opcodes.br, 1 ],
+    [ Opcodes.end ],
+
+    // no fast path for length = 0 as it would probably be slower for most of the time?
+
+    // tmp could have already been used
+    ...number(0, Valtype.i32),
+    [ Opcodes.local_set, index ],
+
+    // setup index end as length * sizeof i16 (2)
+    // we do this instead of having to do mul/div each iter for perf™
+    [ Opcodes.local_get, leftLength ],
+    ...number(ValtypeSize.i16, Valtype.i32),
+    [ Opcodes.i32_mul ],
+    [ Opcodes.local_set, indexEnd ],
+
+    // iterate over each char and check if eq
+    [ Opcodes.loop, Blocktype.void ],
+
+    // fetch left
+    [ Opcodes.local_get, index ],
+    [ Opcodes.local_get, leftPointer ],
+    [ Opcodes.i32_add ],
+    [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+    // fetch right
+    [ Opcodes.local_get, index ],
+    [ Opcodes.local_get, rightPointer ],
+    [ Opcodes.i32_add ],
+    [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+    // not equal, "return" false
+    [ Opcodes.i32_ne ],
+    [ Opcodes.if, Blocktype.void ],
+    ...number(0, Valtype.i32),
+    [ Opcodes.br, 2 ],
+    [ Opcodes.end ],
+
+    // index += sizeof i16 (2)
+    [ Opcodes.local_get, index ],
+    ...number(ValtypeSize.i16, Valtype.i32),
+    [ Opcodes.i32_add ],
+    [ Opcodes.local_tee, index ],
+
+    // if index != index end (length * sizeof 16), loop
+    [ Opcodes.local_get, indexEnd ],
+    [ Opcodes.i32_ne ],
+    [ Opcodes.br_if, 0 ],
+    [ Opcodes.end ],
+
+    // no failed checks, so true!
+    ...number(1, Valtype.i32),
+
+    // pointers match, so true
+    [ Opcodes.else ],
+    ...number(1, Valtype.i32),
+    [ Opcodes.end ],
+
+    // convert i32 result to valtype
+    // do not do as automatically added by binary exp gen for equality ops
+    // Opcodes.i32_from_u
   ];
 };
 
-const truthy = (scope, wasm, type) => {
-  // arrays are always truthy
-  if (type === TYPES._array) return [
+const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
+  if (isIntOp(wasm[wasm.length - 1])) return [
     ...wasm,
-    [ Opcodes.drop ],
-    number(1)
+    ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
   ];
 
-  if (type === TYPES.string) {
-    // if not "" (length = 0)
-    return [
-      // pointer
-      ...wasm,
+  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
 
-      // get length
-      [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+  const def = [
+    // if value != 0
+    [ Opcodes.local_get, tmp ],
 
-      // if length != 0
-      /* [ Opcodes.i32_eqz ],
-      [ Opcodes.i32_eqz ], */
-      Opcodes.i32_from_u
-    ]
-  }
-
-  // if != 0
-  return [
-    ...wasm,
+    // ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
+    ...(!intOut || (intIn && intOut) ? [] : [ Opcodes.i32_to_u ]),
 
     /* Opcodes.eqz,
     [ Opcodes.i32_eqz ],
     Opcodes.i32_from */
   ];
+
+  return [
+    ...wasm,
+    [ Opcodes.local_set, tmp ],
+
+    ...typeSwitch(scope, type, {
+      // [TYPES.number]: def,
+      [TYPES._array]: [
+        // arrays are always truthy
+        ...number(1, intOut ? Valtype.i32 : valtypeBinary)
+      ],
+      [TYPES.string]: [
+        [ Opcodes.local_get, tmp ],
+        ...(intIn ? [] : [ Opcodes.i32_to_u ]),
+
+        // get length
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+
+        // if length != 0
+        /* [ Opcodes.i32_eqz ],
+        [ Opcodes.i32_eqz ], */
+        ...(intOut ? [] : [ Opcodes.i32_from_u ])
+      ],
+      default: def
+    }, intOut ? Valtype.i32 : valtypeBinary)
+  ];
+};
+
+const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
+  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+  return [
+    ...wasm,
+    [ Opcodes.local_set, tmp ],
+
+    ...typeSwitch(scope, type, {
+      [TYPES._array]: [
+        // arrays are always truthy
+        ...number(0, intOut ? Valtype.i32 : valtypeBinary)
+      ],
+      [TYPES.string]: [
+        [ Opcodes.local_get, tmp ],
+        ...(intIn ? [] : [ Opcodes.i32_to_u ]),
+
+        // get length
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+
+        // if length == 0
+        [ Opcodes.i32_eqz ],
+        ...(intOut ? [] : [ Opcodes.i32_from_u ])
+      ],
+      default: [
+        // if value == 0
+        [ Opcodes.local_get, tmp ],
+
+        ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
+        ...(intOut ? [] : [ Opcodes.i32_from_u ])
+      ]
+    }, intOut ? Valtype.i32 : valtypeBinary)
+  ];
 };
 
-const performOp = (scope, op, left, right, leftType, rightType, _global = false, _name = '$unspecified', assign = false) => {
+const nullish = (scope, wasm, type, intIn = false, intOut = false) => {
+  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+  return [
+    ...wasm,
+    [ Opcodes.local_set, tmp ],
+
+    ...typeSwitch(scope, type, {
+      [TYPES.undefined]: [
+        // undefined
+        ...number(1, intOut ? Valtype.i32 : valtypeBinary)
+      ],
+      [TYPES.object]: [
+        // object, null if == 0
+        [ Opcodes.local_get, tmp ],
+
+        ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
+        ...(intOut ? [] : [ Opcodes.i32_from_u ])
+      ],
+      default: [
+        // not
+        ...number(0, intOut ? Valtype.i32 : valtypeBinary)
+      ]
+    }, intOut ? Valtype.i32 : valtypeBinary)
+  ];
+};
+
+const stringOnly = wasm => {
+  if (!Array.isArray(wasm[0])) return [ ...wasm, 'string_only' ];
+  if (wasm.length === 1) return [ [ ...wasm[0], 'string_only' ] ];
+
+  return [
+    [ ...wasm[0], 'string_only|start' ],
+    ...wasm.slice(1, -1),
+    [ ...wasm[wasm.length - 1], 'string_only|end' ]
+  ];
+}
+
+const performOp = (scope, op, left, right, leftType, rightType, _global = false, _name = '$undeclared', assign = false) => {
   if (op === '||' || op === '&&' || op === '??') {
-    return performLogicOp(scope, op, left, right);
+    return performLogicOp(scope, op, left, right, leftType, rightType);
+  }
+
+  const eqOp = ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op);
+  const strictOp = op === '===' || op === '!==';
+
+  const startOut = [], endOut = [];
+  const finalise = out => startOut.concat(out, endOut);
+
+  // if strict (in)equal check types match
+  if (strictOp) {
+    // startOut.push(
+    //   ...leftType,
+    //   ...rightType,
+    //   [ Opcodes.i32_eq ]
+    // );
+
+    // endOut.push(
+    //   [ Opcodes.i32_and ]
+    // );
+
+    // startOut.push(
+    //   [ Opcodes.block, Valtype.i32 ],
+    //   ...leftType,
+    //   ...rightType,
+    //   [ Opcodes.i32_ne ],
+    //   [ Opcodes.if, Blocktype.void ],
+    //   ...number(op === '===' ? 0 : 1, Valtype.i32),
+    //   [ Opcodes.br, 1 ],
+    //   [ Opcodes.end ]
+    // );
+
+    // endOut.push(
+    //   [ Opcodes.end ]
+    // );
+
+    endOut.push(
+      ...leftType,
+      ...rightType,
+      ...(op === '===' ? [
+        [ Opcodes.i32_eq ],
+        [ Opcodes.i32_and ]
+      ] : [
+        [ Opcodes.i32_ne ],
+        [ Opcodes.i32_or ]
+      ])
+    );
   }
 
-  if (leftType === TYPES.string || rightType === TYPES.string) {
-    if (op === '+') {
-      // string concat (a + b)
-      return concatStrings(scope, left, right, _global, _name, assign);
-    }
+  // todo: if equality op and an operand is undefined, return false
+  // todo: niche null hell with 0
 
-    // any other math op, NaN
-    if (!['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op)) return number(NaN);
+  // if (leftType === TYPES.string || rightType === TYPES.string) {
+  //   if (op === '+') {
+  //     // string concat (a + b)
+  //     return finalise(concatStrings(scope, left, right, _global, _name, assign));
+  //   }
 
-    // else leave bool ops
-    // todo: convert string to number if string and number or le/ge op
-    // todo: string equality
-  }
+  //   // not an equality op, NaN
+  //   if (!eqOp) return finalise(number(NaN));
+
+  //   // else leave bool ops
+  //   // todo: convert string to number if string and number/bool
+  //   // todo: string (>|>=|<|<=) string
+
+  //   // string comparison
+  //   if (op === '===' || op === '==') {
+  //     return finalise(compareStrings(scope, left, right));
+  //   }
+
+  //   if (op === '!==' || op === '!=') {
+  //     return finalise([
+  //       ...compareStrings(scope, left, right),
+  //       [ Opcodes.i32_eqz ]
+  //     ]);
+  //   }
+  // }
 
   let ops = operatorOpcode[valtype][op];
 
@@ -551,35 +838,90 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     includeBuiltin(scope, builtinName);
     const idx = funcIndex[builtinName];
 
-    return [
+    return finalise([
       ...left,
       ...right,
       [ Opcodes.call, idx ]
-    ];
+    ]);
   }
 
   if (!ops) return todo(`operator ${op} not implemented yet`); // throw new Error(`unknown operator ${op}`);
 
   if (!Array.isArray(ops)) ops = [ ops ];
+  ops = [ ops ];
+
+  let tmpLeft, tmpRight;
+  // if equal op, check if strings for compareStrings
+  if (op === '===' || op === '==' || op === '!==' || op === '!=') {
+    tmpLeft = localTmp(scope, '__tmpop_left');
+    tmpRight = localTmp(scope, '__tmpop_right');
+
+    ops.unshift(...stringOnly([
+      // if left is string
+      ...leftType,
+      ...number(TYPES.string, Valtype.i32),
+      [ Opcodes.i32_eq ],
+
+      // if right is string
+      ...rightType,
+      ...number(TYPES.string, Valtype.i32),
+      [ Opcodes.i32_eq ],
+
+      // if either are true
+      [ Opcodes.i32_or ],
+      [ Opcodes.if, Blocktype.void ],
+
+      // todo: convert non-strings to strings, for now fail immediately if one is not
+      // if left is not string
+      ...leftType,
+      ...number(TYPES.string, Valtype.i32),
+      [ Opcodes.i32_ne ],
+
+      // if right is not string
+      ...rightType,
+      ...number(TYPES.string, Valtype.i32),
+      [ Opcodes.i32_ne ],
+
+      // if either are true
+      [ Opcodes.i32_or ],
+      [ Opcodes.if, Blocktype.void ],
+      ...number(0, Valtype.i32),
+      [ Opcodes.br, 1 ],
+      [ Opcodes.end ],
 
-  return [
+      ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ]),
+      // ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ]),
+      ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : []),
+      [ Opcodes.br, 1 ],
+      [ Opcodes.end ],
+    ]));
+
+    // if not already in block, add a block
+    // if (endOut.length === 0) {
+      startOut.push(stringOnly([ Opcodes.block, Valtype.i32 ]));
+      // endOut.push(stringOnly([ Opcodes.end ]));
+      endOut.unshift(stringOnly([ Opcodes.end ]));
+    // }
+  }
+
+  return finalise([
     ...left,
+    ...(tmpLeft != null ? stringOnly([ [ Opcodes.local_tee, tmpLeft ] ]) : []),
     ...right,
-    ops
-  ];
+    ...(tmpRight != null ? stringOnly([ [ Opcodes.local_tee, tmpRight ] ]) : []),
+    ...ops
+  ]);
 };
 
 const generateBinaryExp = (scope, decl, _global, _name) => {
-  const out = [
-    ...performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name)
-  ];
+  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);
 
   return out;
 };
 
-const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, memory, localNames = [], globalNames = [] }) => {
+const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [] }) => {
   const existing = funcs.find(x => x.name === name);
   if (existing) return existing;
 
@@ -615,7 +957,6 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     returns,
     returnType: TYPES[returnType ?? 'number'],
     wasm,
-    memory,
     internal: true,
     index: currentFuncIndex++
   };
@@ -634,21 +975,56 @@ const includeBuiltin = (scope, builtin) => {
 };
 
 const generateLogicExp = (scope, decl) => {
-  return performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right));
+  return performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right));
 };
 
+// T = JS type, V = value/pointer
+// 0bTTT
+// qNAN: 0 11111111111 1000000000000000000000000000000000000000000000000001
+// 50 bits usable: 0 11111111111 11??????????????????????????????????????????????????
+// js type: 4 bits
+// internal type: ? bits
+// pointer: 32 bits
+// https://piotrduperas.com/posts/nan-boxing
+// 0x7ffc000000000000
+// budget: 50 bits
+// js type: 4 bits
+// internal type: ? bits
+// pointer: 32 bits
+
+// generic
+// 1              23   4             5
+// 0 11111111111 11TTTTIIII??????????PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+// 1: regular iEEE 754 double NaN
+// 2: extra 1 bit to identify NaN box
+// 3: js type
+// 4: internal type
+// 5: pointer
+
 const TYPES = {
-  number: 0xffffffffffff0,
-  boolean: 0xffffffffffff1,
-  string: 0xffffffffffff2,
-  undefined: 0xffffffffffff3,
-  object: 0xffffffffffff4,
-  function: 0xffffffffffff5,
-  symbol: 0xffffffffffff6,
-  bigint: 0xffffffffffff7,
+  number: 0x00,
+  boolean: 0x01,
+  string: 0x02,
+  undefined: 0x03,
+  object: 0x04,
+  function: 0x05,
+  symbol: 0x06,
+  bigint: 0x07,
 
   // these are not "typeof" types but tracked internally
-  _array: 0xffffffffffff8
+  _array: 0x10,
+  _regexp: 0x11,
+
+  // typed arrays
+  _int8array: 0x20,
+  _uint8array: 0x21,
+  _uint8clampedarray: 0x22,
+  _int16array: 0x23,
+  _uint16array: 0x24,
+  _int32array: 0x25,
+  _uint32array: 0x26,
+  _float32array: 0x27,
+  _float64array: 0x28,
 };
 
 const TYPE_NAMES = {
@@ -661,108 +1037,178 @@ const TYPE_NAMES = {
   [TYPES.symbol]: 'Symbol',
   [TYPES.bigint]: 'BigInt',
 
-  [TYPES._array]: 'Array'
+  [TYPES._array]: 'Array',
+  [TYPES._regexp]: 'RegExp'
 };
 
-let typeStates = {};
-
 const getType = (scope, _name) => {
   const name = mapName(_name);
-  if (scope.locals[name]) return typeStates[name];
 
-  if (builtinVars[name]) return TYPES[builtinVars[name].type ?? 'number'];
-  if (builtinFuncs[name] !== undefined || importedFuncs[name] !== undefined || funcIndex[name] !== undefined || internalConstrs[name] !== undefined) return TYPES.function;
-  if (globals[name]) return typeStates[name];
+  if (scope.locals[name]) return [ [ Opcodes.local_get, scope.locals[name + '#type'].idx ] ];
+  if (globals[name]) return [ [ Opcodes.global_get, globals[name + '#type'].idx ] ];
+
+  let type = TYPES.undefined;
+  if (builtinVars[name]) type = TYPES[builtinVars[name].type ?? 'number'];
+  if (builtinFuncs[name] !== undefined || importedFuncs[name] !== undefined || funcIndex[name] !== undefined || internalConstrs[name] !== undefined) type = TYPES.function;
 
-  if (name.startsWith('__Array_prototype_') && prototypeFuncs[TYPES._array][name.slice(18)]) return TYPES.function;
-  if (name.startsWith('__String_prototype_') && prototypeFuncs[TYPES.string][name.slice(19)]) return TYPES.function;
+  if (name.startsWith('__Array_prototype_') && prototypeFuncs[TYPES._array][name.slice(18)] ||
+    name.startsWith('__String_prototype_') && prototypeFuncs[TYPES.string][name.slice(19)]) type = TYPES.function;
 
-  return TYPES.undefined;
+  return number(type, Valtype.i32);
 };
 
-const getNodeType = (scope, node) => {
-  if (node.type === 'Literal') {
-    return TYPES[typeof node.value];
-  }
+const setType = (scope, _name, type) => {
+  const name = mapName(_name);
 
-  if (isFuncType(node.type)) {
-    return TYPES.function;
-  }
+  const out = typeof type === 'number' ? number(type, Valtype.i32) : type;
 
-  if (node.type === 'Identifier') {
-    return getType(scope, node.name);
-  }
+  if (scope.locals[name]) return [
+    ...out,
+    [ Opcodes.local_set, scope.locals[name + '#type'].idx ]
+  ];
 
-  if (node.type === 'CallExpression' || node.type === 'NewExpression') {
-    const name = node.callee.name;
-    const func = funcs.find(x => x.name === name);
-    if (func) return func.returnType ?? TYPES.number;
+  if (globals[name]) return [
+    ...out,
+    [ Opcodes.global_set, globals[name + '#type'].idx ]
+  ];
+
+  // throw new Error('could not find var');
+};
 
-    if (builtinFuncs[name]) return TYPES[builtinFuncs[name].returnType ?? 'number'];
-    if (internalConstrs[name]) return internalConstrs[name].type;
+const getNodeType = (scope, node) => {
+  const inner = () => {
+    if (node.type === 'Literal') {
+      if (node.regex) return TYPES._regexp;
 
-    let protoFunc;
-    // ident.func()
-    if (name && name.startsWith('__')) {
-      const spl = name.slice(2).split('_');
+      return TYPES[typeof node.value];
+    }
 
-      const baseName = spl.slice(0, -1).join('_');
-      const baseType = getType(scope, baseName);
+    if (isFuncType(node.type)) {
+      return TYPES.function;
+    }
 
-      const func = spl[spl.length - 1];
-      protoFunc = prototypeFuncs[baseType]?.[func];
+    if (node.type === 'Identifier') {
+      return getType(scope, node.name);
     }
 
-    // literal.func()
-    if (!name && node.callee.type === 'MemberExpression') {
-      const baseType = getNodeType(scope, node.callee.object);
+    if (node.type === 'CallExpression' || node.type === 'NewExpression') {
+      const name = node.callee.name;
+      const func = funcs.find(x => x.name === name);
+
+      if (func) {
+        // console.log(scope, func, func.returnType);
+        if (func.returnType) return func.returnType;
+      }
+
+      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) ] ];
 
-      const func = node.callee.property.name;
-      protoFunc = prototypeFuncs[baseType]?.[func];
+      // presume
+      // todo: warn here?
+      return TYPES.number;
+
+      // let protoFunc;
+      // // ident.func()
+      // if (name && name.startsWith('__')) {
+      //   const spl = name.slice(2).split('_');
+
+      //   const baseName = spl.slice(0, -1).join('_');
+      //   const baseType = getType(scope, baseName);
+
+      //   const func = spl[spl.length - 1];
+      //   protoFunc = prototypeFuncs[baseType]?.[func];
+      // }
+
+      // // literal.func()
+      // if (!name && node.callee.type === 'MemberExpression') {
+      //   if (node.callee.object.regex) {
+      //     const funcName = node.callee.property.name;
+      //     return Rhemyn[funcName] ? TYPES.boolean : TYPES.undefined;
+      //   }
+
+      //   const baseType = getNodeType(scope, node.callee.object);
+
+      //   const func = node.callee.property.name;
+      //   protoFunc = prototypeFuncs[baseType]?.[func];
+      // }
+
+      // if (protoFunc) return protoFunc.returnType;
     }
 
-    if (protoFunc) return protoFunc.returnType ?? TYPES.number;
+    if (node.type === 'ExpressionStatement') {
+      return getNodeType(scope, node.expression);
+    }
 
-    return TYPES.number;
-  }
+    if (node.type === 'AssignmentExpression') {
+      return getNodeType(scope, node.right);
+    }
 
-  if (node.type === 'ExpressionStatement') {
-    return getNodeType(scope, node.expression);
-  }
+    if (node.type === 'ArrayExpression') {
+      return TYPES._array;
+    }
 
-  if (node.type === 'AssignmentExpression') {
-    return getNodeType(scope, node.right);
-  }
+    if (node.type === 'BinaryExpression') {
+      if (['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(node.operator)) return TYPES.boolean;
+      return TYPES.number;
+
+      // todo: string concat types
+      // if (node.operator !== '+') return TYPES.number;
+      //   else return [
+      //     // if left is string
+      //     ...getNodeType(scope, node.left),
+      //     ...number(TYPES.string, Valtype.i32),
+      //     [ Opcodes.i32_eq ],
+
+      //     // if right is string
+      //     ...getNodeType(scope, node.right),
+      //     ...number(TYPES.string, Valtype.i32),
+      //     [ Opcodes.i32_eq ],
+
+      //     // if either are true
+      //     [ Opcodes.i32_or ],
+      //   ];
+    }
 
-  if (node.type === 'ArrayExpression') {
-    return TYPES._array;
-  }
+    if (node.type === 'UnaryExpression') {
+      if (node.operator === '!') return TYPES.boolean;
+      if (node.operator === 'void') return TYPES.undefined;
+      if (node.operator === 'delete') return TYPES.boolean;
+      if (node.operator === 'typeof') return TYPES.string;
 
-  if (node.type === 'BinaryExpression') {
-    if (['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(node.operator)) return TYPES.boolean;
+      return TYPES.number;
+    }
 
-    if (node.operator === '+' && (getNodeType(scope, node.left) === TYPES.string || getNodeType(scope, node.right) === TYPES.string)) return TYPES.string;
-  }
+    if (node.type === 'MemberExpression') {
+      // hack: if something.length, number type
+      if (node.property.name === 'length') return TYPES.number;
 
-  if (node.type === 'UnaryExpression') {
-    if (node.operator === '!') return TYPES.boolean;
-    if (node.operator === 'void') return TYPES.undefined;
-    if (node.operator === 'delete') return TYPES.boolean;
-  }
+      // we cannot guess
+      return TYPES.number;
+    }
 
-  if (node.type === 'MemberExpression') {
-    const objectType = getNodeType(scope, node.object);
+    if (scope.locals['#last_type']) return [ [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ] ];
 
-    if (objectType === TYPES.string && node.computed) return TYPES.string;
-  }
+    // presume
+    // todo: warn here?
+    return TYPES.number;
+  };
 
-  // default to number
-  return TYPES.number;
+  const ret = inner();
+  // console.trace(node, ret);
+  if (typeof ret === 'number') return number(ret, Valtype.i32);
+  return ret;
 };
 
 const generateLiteral = (scope, decl, global, name) => {
   if (decl.value === null) return number(NULL);
 
+  if (decl.regex) {
+    scope.regex[name] = decl.regex;
+    return number(1);
+  }
+
   switch (typeof decl.value) {
     case 'number':
       return number(decl.value);
@@ -772,27 +1218,16 @@ const generateLiteral = (scope, decl, global, name) => {
       return number(decl.value ? 1 : 0);
 
     case 'string':
-      // this is a terrible hack which changes type strings ("number" etc) to known const number values
-      switch (decl.value) {
-        case 'number': return number(TYPES.number);
-        case 'boolean': return number(TYPES.boolean);
-        case 'string': return number(TYPES.string);
-        case 'undefined': return number(TYPES.undefined);
-        case 'object': return number(TYPES.object);
-        case 'function': return number(TYPES.function);
-        case 'symbol': return number(TYPES.symbol);
-        case 'bigint': return number(TYPES.bigint);
-      }
-
       const str = decl.value;
       const rawElements = new Array(str.length);
+      let j = 0;
       for (let i = 0; i < str.length; i++) {
         rawElements[i] = str.charCodeAt(i);
       }
 
       return makeArray(scope, {
         rawElements
-      }, global, name, false, 'i16');
+      }, global, name, false, 'i16')[0];
 
     default:
       return todo(`cannot generate literal of type ${typeof decl.value}`);
@@ -802,7 +1237,8 @@ const generateLiteral = (scope, decl, global, name) => {
 const countLeftover = wasm => {
   let count = 0, depth = 0;
 
-  for (const inst of wasm) {
+  for (let i = 0; i < wasm.length; i++) {
+    const inst = wasm[i];
     if (depth === 0 && (inst[0] === Opcodes.if || inst[0] === Opcodes.block || inst[0] === Opcodes.loop)) {
       if (inst[0] === Opcodes.if) count--;
       if (inst[1] !== Blocktype.void) count++;
@@ -811,11 +1247,12 @@ const countLeftover = wasm => {
     if (inst[0] === Opcodes.end) depth--;
 
     if (depth === 0)
-      if ([Opcodes.throw, Opcodes.return, Opcodes.drop, Opcodes.local_set, Opcodes.global_set].includes(inst[0])) count--;
+      if ([Opcodes.throw,Opcodes.drop, Opcodes.local_set, Opcodes.global_set].includes(inst[0])) count--;
         else if ([null, Opcodes.i32_eqz, Opcodes.i64_eqz, Opcodes.f64_ceil, Opcodes.f64_floor, Opcodes.f64_trunc, Opcodes.f64_nearest, Opcodes.f64_sqrt, Opcodes.local_tee, Opcodes.i32_wrap_i64, Opcodes.i64_extend_i32_s, Opcodes.i64_extend_i32_u, Opcodes.f32_demote_f64, Opcodes.f64_promote_f32, Opcodes.f64_convert_i32_s, Opcodes.f64_convert_i32_u, Opcodes.i32_clz, Opcodes.i32_ctz, Opcodes.i32_popcnt, Opcodes.f64_neg, Opcodes.end, Opcodes.i32_trunc_sat_f64_s[0], Opcodes.i32x4_extract_lane, Opcodes.i16x8_extract_lane, Opcodes.i32_load, Opcodes.i64_load, Opcodes.f64_load, Opcodes.v128_load, Opcodes.i32_load16_u, Opcodes.i32_load16_s, Opcodes.memory_grow].includes(inst[0]) && (inst[0] !== 0xfc || inst[1] < 0x0a)) {}
         else if ([Opcodes.local_get, Opcodes.global_get, Opcodes.f64_const, Opcodes.i32_const, Opcodes.i64_const, Opcodes.v128_const].includes(inst[0])) count++;
         else if ([Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store, Opcodes.i32_store16].includes(inst[0])) count -= 2;
         else if (Opcodes.memory_copy[0] === inst[0] && Opcodes.memory_copy[1] === inst[1]) count -= 3;
+        else if (inst[0] === Opcodes.return) count = 0;
         else if (inst[0] === Opcodes.call) {
           let func = funcs.find(x => x.index === inst[1]);
           if (func) {
@@ -823,6 +1260,8 @@ const countLeftover = wasm => {
           } else count--;
           if (func) count += func.returns.length;
         } else count--;
+
+    // console.log(count, decompile([ inst ]).slice(0, -1));
   }
 
   return count;
@@ -843,7 +1282,7 @@ const generateExp = (scope, decl) => {
   return out;
 };
 
-const arrayUtil = {
+const CTArrayUtil = {
   getLengthI32: pointer => [
     ...number(0, Valtype.i32),
     [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ]
@@ -869,6 +1308,32 @@ const arrayUtil = {
   ]
 };
 
+const RTArrayUtil = {
+  getLengthI32: pointer => [
+    ...pointer,
+    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ]
+  ],
+
+  getLength: pointer => [
+    ...pointer,
+    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+    Opcodes.i32_from_u
+  ],
+
+  setLengthI32: (pointer, value) => [
+    ...pointer,
+    ...value,
+    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ]
+  ],
+
+  setLength: (pointer, value) => [
+    ...pointer,
+    ...value,
+    Opcodes.i32_to_u,
+    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ]
+  ]
+};
+
 const generateCall = (scope, decl, _global, _name) => {
   /* const callee = decl.callee;
   const args = decl.arguments;
@@ -898,95 +1363,166 @@ const generateCall = (scope, decl, _global, _name) => {
     const lastInst = out[out.length - 1];
     if (lastInst && lastInst[0] === Opcodes.drop) {
       out.splice(out.length - 1, 1);
+
+      const finalStatement = parsed.body[parsed.body.length - 1];
+      out.push(
+        ...getNodeType(scope, finalStatement),
+        [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+      );
     } 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) ]
+      );
     }
 
+    // if (lastInst && lastInst[0] === Opcodes.drop) {
+    //   out.splice(out.length - 1, 1);
+    // } else if (countLeftover(out) === 0) {
+    //   out.push(...number(UNDEFINED));
+    // }
+
     return out;
   }
 
-  let out = [];
-  let protoFunc, protoName, baseType, baseName = '$undeclared';
+  let protoName, target;
   // ident.func()
   if (name && name.startsWith('__')) {
     const spl = name.slice(2).split('_');
 
-    baseName = spl.slice(0, -1).join('_');
-    baseType = getType(scope, baseName);
-
     const func = spl[spl.length - 1];
-    protoFunc = prototypeFuncs[baseType]?.[func] ?? Object.values(prototypeFuncs).map(x => x[func]).find(x => x);
     protoName = func;
+
+    target = { ...decl.callee };
+    target.name = spl.slice(0, -1).join('_');
   }
 
   // literal.func()
   if (!name && decl.callee.type === 'MemberExpression') {
-    baseType = getNodeType(scope, decl.callee.object);
+    // megahack for /regex/.func()
+    if (decl.callee.object.regex) {
+      const funcName = decl.callee.property.name;
+      const func = Rhemyn[funcName](decl.callee.object.regex.pattern, currentFuncIndex++);
+
+      funcIndex[func.name] = func.index;
+      funcs.push(func);
+
+      return [
+        // make string arg
+        ...generate(scope, decl.arguments[0]),
+
+        // call regex func
+        Opcodes.i32_to_u,
+        [ Opcodes.call, func.index ],
+        Opcodes.i32_from_u,
+
+        ...number(TYPES.boolean, Valtype.i32),
+        [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+      ];
+    }
 
     const func = decl.callee.property.name;
-    protoFunc = prototypeFuncs[baseType]?.[func] ?? Object.values(prototypeFuncs).map(x => x[func]).find(x => x);
     protoName = func;
 
-    out = generate(scope, decl.callee.object);
-    out.push([ Opcodes.drop ]);
+    target = decl.callee.object;
   }
 
-  if (protoFunc) {
-    scope.memory = true;
+  // if (protoName && baseType === TYPES.string && Rhemyn[protoName]) {
+  //   const func = Rhemyn[protoName](decl.arguments[0].regex.pattern, currentFuncIndex++);
 
-    let pointer = arrays.get(baseName);
+  //   funcIndex[func.name] = func.index;
+  //   funcs.push(func);
 
-    if (pointer == null) {
-      // unknown dynamic pointer, so clone to new pointer which we know aot. now that's what I call inefficient™
-      if (codeLog) log('codegen', 'cloning unknown dynamic pointer');
+  //   return [
+  //     generate(scope, decl.callee.object)
 
-      // register array
-      makeArray(scope, {
-        rawElements: new Array(0)
-      }, _global, baseName, true, baseType === TYPES.string ? 'i16' : valtype);
-      pointer = arrays.get(baseName);
+  //     // call regex func
+  //     [ Opcodes.call, func.index ],
+  //     Opcodes.i32_from_u
+  //   ];
+  // }
 
-      const [ local, isGlobal ] = lookupName(scope, baseName);
+  if (protoName) {
+    const protoCands = Object.keys(prototypeFuncs).reduce((acc, x) => {
+      const f = prototypeFuncs[x][protoName];
+      if (f) acc[x] = f;
+      return acc;
+    }, {});
 
-      out = [
-        // clone to new pointer
-        ...number(pointer, Valtype.i32), // dst = new pointer
-        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ], // src = unknown pointer
-        Opcodes.i32_to_u,
-        ...number(pageSize, Valtype.i32), // size = pagesize
+    // no prototype function candidates, ignore
+    if (Object.keys(protoCands).length > 0) {
+      // use local for cached i32 length as commonly used
+      const lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
+      const pointerLocal = localTmp(scope, '__proto_pointer_cache', Valtype.i32);
+      const getPointer = [ [ Opcodes.local_get, pointerLocal ] ];
 
-        [ ...Opcodes.memory_copy, 0x00, 0x00 ],
-      ];
-    }
+      // TODO: long-term, prototypes should be their individual separate funcs
+
+      let lengthI32CacheUsed = false;
+      const protoBC = {};
+      for (const x in protoCands) {
+        const protoFunc = protoCands[x];
+        if (protoFunc.noArgRetLength && decl.arguments.length === 0) {
+          protoBC[x] = [
+            ...RTArrayUtil.getLength(getPointer),
+
+            ...number(TYPES.number, Valtype.i32),
+            [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+          ];
+          continue;
+        }
 
-    if (protoFunc.noArgRetLength && decl.arguments.length === 0) return arrayUtil.getLength(pointer)
+        // const protoLocal = protoFunc.local ? localTmp(scope, `__${TYPE_NAMES[x]}_${protoName}_tmp`, protoFunc.local) : -1;
+        // const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${TYPE_NAMES[x]}_${protoName}_tmp2`, protoFunc.local2) : -1;
+        const protoLocal = protoFunc.local ? localTmp(scope, `__${protoName}_tmp`, protoFunc.local) : -1;
+        const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${protoName}_tmp2`, protoFunc.local2) : -1;
+
+        const protoOut = protoFunc(getPointer, {
+          getCachedI32: () => {
+            lengthI32CacheUsed = true;
+            return [ [ Opcodes.local_get, lengthLocal ] ];
+          },
+          setCachedI32: () => [ [ Opcodes.local_set, lengthLocal ] ],
+          get: () => RTArrayUtil.getLength(getPointer),
+          getI32: () => RTArrayUtil.getLengthI32(getPointer),
+          set: value => RTArrayUtil.setLength(getPointer, value),
+          setI32: value => RTArrayUtil.setLengthI32(getPointer, value)
+        }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, protoLocal2, (length, itemType) => {
+          return makeArray(scope, {
+            rawElements: new Array(length)
+          }, _global, _name, true, itemType);
+        });
+
+        protoBC[x] = [
+          [ Opcodes.block, valtypeBinary ],
+          ...protoOut,
+
+          ...number(protoFunc.returnType ?? TYPES.number, Valtype.i32),
+          [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+          [ Opcodes.end ]
+        ];
+      }
 
-    let protoLocal = protoFunc.local ? localTmp(scope, `__${TYPE_NAMES[baseType]}_${protoName}_tmp`, protoFunc.local) : -1;
+      return [
+        ...generate(scope, target),
 
-    // use local for cached i32 length as commonly used
-    let lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
+        Opcodes.i32_to_u,
+        [ Opcodes.local_set, pointerLocal ],
 
-    return [
-      ...out,
-
-      ...arrayUtil.getLengthI32(pointer),
-      [ Opcodes.local_set, lengthLocal ],
-
-      [ Opcodes.block, valtypeBinary ],
-      ...protoFunc(pointer, {
-        cachedI32: [ [ Opcodes.local_get, lengthLocal ] ],
-        get: arrayUtil.getLength(pointer),
-        getI32: arrayUtil.getLengthI32(pointer),
-        set: value => arrayUtil.setLength(pointer, value),
-        setI32: value => arrayUtil.setLengthI32(pointer, value)
-      }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, (length, itemType) => {
-        const out = makeArray(scope, {
-          rawElements: new Array(length)
-        }, _global, _name, true, itemType);
-        return [ out, arrays.get(_name ?? '$undeclared') ];
-      }),
-      [ Opcodes.end ]
-    ];
+        ...(!lengthI32CacheUsed ? [] : [
+          ...RTArrayUtil.getLengthI32(getPointer),
+          [ Opcodes.local_set, lengthLocal ],
+        ]),
+
+        ...typeSwitch(scope, getNodeType(scope, target), {
+          ...protoBC,
+
+          // TODO: error better
+          default: internalThrow(scope, 'TypeError', `'${protoName}' proto func tried to be called on a type without an impl`)
+        }, valtypeBinary),
+      ];
+    }
   }
 
   // TODO: only allows callee as literal
@@ -1030,34 +1566,50 @@ 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);
+
   let args = decl.arguments;
-  if (func && args.length < func.params.length) {
+  if (func && args.length < paramCount) {
     // too little args, push undefineds
-    args = args.concat(new Array(func.params.length - args.length).fill(DEFAULT_VALUE));
+    args = args.concat(new Array(paramCount - args.length).fill(DEFAULT_VALUE));
   }
 
-  if (func && args.length > func.params.length) {
+  if (func && args.length > paramCount) {
     // too many args, slice extras off
-    args = args.slice(0, func.params.length);
+    args = args.slice(0, paramCount);
   }
 
-  if (func && func.memory) scope.memory = true;
   if (func && func.throws) scope.throws = true;
 
+  let out = [];
   for (const arg of args) {
-    out.push(...generate(scope, arg));
+    out = out.concat(generate(scope, arg));
+    if (userFunc) out = out.concat(getNodeType(scope, arg));
   }
 
   out.push([ Opcodes.call, idx ]);
 
+  if (!userFunc) {
+    // let type;
+    // if (builtinFuncs[name]) type = TYPES[builtinFuncs[name].returnType ?? 'number'];
+    // if (internalConstrs[name]) type = internalConstrs[name].type;
+    // if (importedFuncs[name] && importedFuncs[]) type =
+
+    // if (type) out.push(
+    //   ...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) ]);
+
   return out;
 };
 
 const generateNew = (scope, decl, _global, _name) => {
   // hack: basically treat this as a normal call for builtins for now
   const name = mapName(decl.callee.name);
-  if (internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
-  if (!builtinFuncs[name]) return todo(`new statement is not supported yet (new ${unhackName(name)})`);
+  if (internalConstrs[name] && !internalConstrs[name].notConstr) return internalConstrs[name].generate(scope, decl, _global, _name);
+  if (!builtinFuncs[name]) return todo(`new statement is not supported yet`); // return todo(`new statement is not supported yet (new ${unhackName(name)})`);
 
   return generateCall(scope, decl, _global, _name);
 };
@@ -1073,14 +1625,67 @@ const unhackName = name => {
   return name;
 };
 
+const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
+  const tmp = localTmp(scope, '#typeswitch_tmp', Valtype.i32);
+
+  const out = [
+    ...type,
+    [ Opcodes.local_set, tmp ],
+    [ Opcodes.block, returns ]
+  ];
+
+  // todo: use br_table?
+
+  for (const x in bc) {
+    if (x === 'default') continue;
+
+    // if type == x
+    out.push([ Opcodes.local_get, tmp ]);
+    out.push(...number(x, Valtype.i32));
+    out.push([ Opcodes.i32_eq ]);
+
+    out.push([ Opcodes.if, Blocktype.void, `TYPESWITCH|${TYPE_NAMES[x]}` ]);
+    out.push(...bc[x]);
+    out.push([ Opcodes.br, 1 ]);
+    out.push([ Opcodes.end ]);
+  }
+
+  // default
+  if (bc.default) out.push(...bc.default);
+    else if (returns !== Blocktype.void) out.push(...number(0, returns));
+
+  out.push([ Opcodes.end, 'TYPESWITCH_end' ]);
+
+  return out;
+};
+
+const allocVar = (scope, name, global = false) => {
+  const target = global ? globals : scope.locals;
+
+  // already declared
+  if (target[name]) {
+    // parser should catch this but sanity check anyway
+    // if (decl.kind !== 'var') return internalThrow(scope, 'SyntaxError', `Identifier '${unhackName(name)}' has already been declared`);
+
+    return target[name].idx;
+  }
+
+  let idx = global ? globalInd++ : scope.localInd++;
+  target[name] = { idx, type: valtypeBinary };
+
+  let typeIdx = global ? globalInd++ : scope.localInd++;
+  target[name + '#type'] = { idx: typeIdx, type: Valtype.i32 };
+
+  return idx;
+};
+
 const generateVar = (scope, decl) => {
-  const out = [];
+  let out = [];
 
   const topLevel = scope.name === 'main';
 
   // global variable if in top scope (main) and var ..., or if wanted
-  const global = decl.kind === 'var';
-  const target = global ? globals : scope.locals;
+  const global = topLevel || decl._bare; // decl.kind === 'var';
 
   for (const x of decl.declarations) {
     const name = mapName(x.id.name);
@@ -1100,46 +1705,16 @@ const generateVar = (scope, decl) => {
       continue; // always ignore
     }
 
-    let idx;
-    // already declared
-    if (target[name]) {
-      // parser should catch this but sanity check anyway
-      if (decl.kind !== 'var') return internalThrow(scope, 'SyntaxError', `Identifier '${unhackName(name)}' has already been declared`);
-
-      idx = target[name].idx;
-    } else {
-      idx = global ? globalInd++ : scope.localInd++;
-      target[name] = { idx, type: valtypeBinary };
-    }
-
-    typeStates[name] = x.init ? getNodeType(scope, x.init) : TYPES.undefined;
-
-    // x.init ??= DEFAULT_VALUE;
+    let idx = allocVar(scope, name, global);
     if (x.init) {
-      out.push(...generate(scope, x.init, global, name));
-
-      // if our value is the result of a function, infer the type from that func's return value
-      if (out[out.length - 1][0] === Opcodes.call) {
-        const ind = out[out.length - 1][1];
-        if (ind >= importedFuncs.length) { // not an imported func
-          const func = funcs.find(x => x.index === ind);
-          if (!func) throw new Error('could not find func being called as var value to infer type'); // sanity check
-
-          const returns = func.returns;
-          if (returns.length > 1) throw new Error('func returning >1 value being set as 1 local'); // sanity check
-
-          target[name].type = func.returns[0];
-          if (target[name].type === Valtype.v128) {
-            // specify vec subtype inferred from first vec type in function name
-            target[name].vecType = func.name.split('_').find(x => x.includes('x'));
-          }
-        } else {
-          // we do not have imports that return yet, ignore for now
-        }
-      }
+      out = out.concat(generate(scope, x.init, global, name));
 
       out.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
+      out.push(...setType(scope, name, getNodeType(scope, x.init)));
     }
+
+    // hack: this follows spec properly but is mostly unneeded 😅
+    // out.push(...setType(scope, name, x.init ? getNodeType(scope, x.init) : TYPES.undefined));
   }
 
   return out;
@@ -1165,8 +1740,6 @@ const generateAssign = (scope, decl) => {
     const name = decl.left.object.name;
     const pointer = arrays.get(name);
 
-    scope.memory = true;
-
     const aotPointer = pointer != null;
 
     const newValueTmp = localTmp(scope, '__length_setter_tmp');
@@ -1177,7 +1750,7 @@ const generateAssign = (scope, decl) => {
         Opcodes.i32_to_u
       ]),
 
-      ...generate(scope, decl.right, false, name),
+      ...generate(scope, decl.right),
       [ Opcodes.local_tee, newValueTmp ],
 
       Opcodes.i32_to_u,
@@ -1187,13 +1760,76 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
+  const op = decl.operator.slice(0, -1) || '=';
+
+  // arr[i]
+  if (decl.left.type === 'MemberExpression' && decl.left.computed) {
+    const name = decl.left.object.name;
+    const pointer = arrays.get(name);
+
+    const aotPointer = pointer != null;
+
+    const newValueTmp = localTmp(scope, '__member_setter_val_tmp');
+    const pointerTmp = op === '=' ? -1 : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
+
+    return [
+      ...typeSwitch(scope, getNodeType(scope, decl.left.object), {
+        [TYPES._array]: [
+          ...(aotPointer ? [] : [
+            ...generate(scope, decl.left.object),
+            Opcodes.i32_to_u
+          ]),
+
+          // get index as valtype
+          ...generate(scope, decl.left.property),
+          Opcodes.i32_to_u,
+
+          // turn into byte offset by * valtypeSize (4 for i32, 8 for i64/f64)
+          ...number(ValtypeSize[valtype], Valtype.i32),
+          [ Opcodes.i32_mul ],
+          ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+          [ Opcodes.local_tee, newValueTmp ],
+
+          [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+        ],
+
+        default: internalThrow(scope, 'TypeError', `Cannot assign member with non-array`)
+
+        // [TYPES.string]: [
+        //   // turn into byte offset by * sizeof i16
+        //   ...number(ValtypeSize.i16, Valtype.i32),
+        //   [ Opcodes.i32_mul ],
+        //   ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
+        //   ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+        //   ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+        //     [ Opcodes.local_get, pointerTmp ],
+        //     [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+        //   ], generate(scope, decl.right), number(TYPES.string, Valtype.i32), getNodeType(scope, decl.right))),
+        //   [ Opcodes.local_tee, newValueTmp ],
+
+        //   Opcodes.i32_to_u,
+        //   [ StoreOps.i16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+        // ]
+      }, Blocktype.void),
+
+      [ Opcodes.local_get, newValueTmp ]
+    ];
+  }
+
   const [ local, isGlobal ] = lookupName(scope, name);
 
   if (local === undefined) {
-    // todo: this should be a devtools/repl/??? only thing
+    // todo: this should be a sloppy mode only thing
 
     // only allow = for this
-    if (decl.operator !== '=') return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`);
+    if (op !== '=') return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`);
 
     if (builtinVars[name]) {
       // just return rhs (eg `NaN = 2`)
@@ -1202,25 +1838,53 @@ const generateAssign = (scope, decl) => {
 
     // set global and return (eg a = 2)
     return [
-      ...generateVar(scope, { kind: 'var', declarations: [ { id: { name }, init: decl.right } ] }),
+      ...generateVar(scope, { kind: 'var', _bare: true, declarations: [ { id: { name }, init: decl.right } ] }),
       [ Opcodes.global_get, globals[name].idx ]
     ];
   }
 
-  if (decl.operator === '=') {
-    typeStates[name] = getNodeType(scope, decl.right);
-
+  if (op === '=') {
     return [
       ...generate(scope, decl.right, isGlobal, name),
       [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
-      [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ]
+      [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+
+      ...setType(scope, name, getNodeType(scope, decl.right))
+    ];
+  }
+
+  if (op === '||' || op === '&&' || op === '??') {
+    // todo: is this needed?
+    // for logical assignment ops, it is not left @= right ~= left = left @ right
+    // instead, left @ (left = right)
+    // eg, x &&= y ~= x && (x = y)
+
+    return [
+      ...performOp(scope, op, [
+        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ]
+      ], [
+        ...generate(scope, decl.right),
+        [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ]
+      ], 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) ],
+      // hack: type is idx+1
+      [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx + 1 ],
     ];
   }
 
   return [
-    ...performOp(scope, decl.operator.slice(0, -1), [ [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ] ], generate(scope, decl.right), getType(scope, name), getNodeType(scope, decl.right), isGlobal, name, true),
+    ...performOp(scope, op, [ [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ] ], generate(scope, decl.right), getType(scope, name), getNodeType(scope, decl.right), isGlobal, name, true),
     [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
-    [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ]
+    [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+
+    // todo: string concat types
+
+    // hack: type is idx+1
+    ...number(TYPES.number, Valtype.i32),
+    [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx + 1 ],
   ];
 };
 
@@ -1245,13 +1909,14 @@ const generateUnary = (scope, decl) => {
 
     case '!':
       // !=
-      return falsy(scope, generate(scope, decl.argument));
+      return falsy(scope, generate(scope, decl.argument), getNodeType(scope, decl.argument), false, false);
 
     case '~':
+      // todo: does not handle Infinity properly (should convert to 0) (but opt const converting saves us sometimes)
       return [
         ...generate(scope, decl.argument),
         Opcodes.i32_to,
-        [ Opcodes.i32_const, signedLEB128(-1) ],
+        [ Opcodes.i32_const, ...signedLEB128(-1) ],
         [ Opcodes.i32_xor ],
         Opcodes.i32_from
       ];
@@ -1289,11 +1954,16 @@ const generateUnary = (scope, decl) => {
       return out;
 
     case 'typeof':
-      const type = getNodeType(scope, decl.argument);
+      return typeSwitch(scope, getNodeType(scope, decl.argument), {
+        [TYPES.number]: makeString(scope, 'number', false, '#typeof_result'),
+        [TYPES.boolean]: makeString(scope, 'boolean', false, '#typeof_result'),
+        [TYPES.string]: makeString(scope, 'string', false, '#typeof_result'),
+        [TYPES.undefined]: makeString(scope, 'undefined', false, '#typeof_result'),
+        [TYPES.function]: makeString(scope, 'function', false, '#typeof_result'),
 
-      // for custom types, just return object
-      if (type > 0xffffffffffff7) return number(TYPES.object);
-      return number(type);
+        // object and internal types
+        default: makeString(scope, 'object', false, '#typeof_result'),
+      });
 
     default:
       return todo(`unary operator ${decl.operator} not implemented yet`);
@@ -1332,9 +2002,9 @@ const generateUpdate = (scope, decl) => {
 };
 
 const generateIf = (scope, decl) => {
-  const out = truthy(scope, generate(scope, decl.test), decl.test);
+  const out = truthy(scope, generate(scope, decl.test), getNodeType(scope, decl.test), false, true);
 
-  out.push(Opcodes.i32_to, [ Opcodes.if, Blocktype.void ]);
+  out.push([ Opcodes.if, Blocktype.void ]);
   depth.push('if');
 
   const consOut = generate(scope, decl.consequent);
@@ -1356,16 +2026,28 @@ const generateIf = (scope, decl) => {
 };
 
 const generateConditional = (scope, decl) => {
-  const out = [ ...generate(scope, decl.test) ];
+  const out = truthy(scope, generate(scope, decl.test), getNodeType(scope, decl.test), false, true);
 
-  out.push(Opcodes.i32_to, [ Opcodes.if, valtypeBinary ]);
+  out.push([ Opcodes.if, valtypeBinary ]);
   depth.push('if');
 
   out.push(...generate(scope, decl.consequent));
 
+  // note type
+  out.push(
+    ...getNodeType(scope, decl.consequent),
+    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+  );
+
   out.push([ Opcodes.else ]);
   out.push(...generate(scope, decl.alternate));
 
+  // note type
+  out.push(
+    ...getNodeType(scope, decl.alternate),
+    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+  );
+
   out.push([ Opcodes.end ]);
   depth.pop();
 
@@ -1422,9 +2104,148 @@ const generateWhile = (scope, decl) => {
   return out;
 };
 
+const generateForOf = (scope, decl) => {
+  const out = [];
+
+  // todo: for of inside for of might fuck up?
+  const pointer = localTmp(scope, 'forof_base_pointer', Valtype.i32);
+  const length = localTmp(scope, 'forof_length', Valtype.i32);
+  const counter = localTmp(scope, 'forof_counter', Valtype.i32);
+
+  out.push(
+    // set pointer as right
+    ...generate(scope, decl.right),
+    Opcodes.i32_to_u,
+    [ Opcodes.local_set, pointer ],
+
+    // set counter as 0 (could be already used)
+    ...number(0, Valtype.i32),
+    [ Opcodes.local_set, counter ],
+
+    // get length
+    [ Opcodes.local_get, pointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+    [ Opcodes.local_set, length ]
+  );
+
+  depth.push('forof');
+
+  // setup local for left
+  generate(scope, decl.left);
+
+  const leftName = decl.left.declarations[0].id.name;
+  const [ local, isGlobal ] = lookupName(scope, leftName);
+
+  depth.push('block');
+  depth.push('block');
+
+  // // 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;
+  if (pages.hasString) {
+    0, [ newOut, newPointer ] = makeArray(scope, {
+      rawElements: new Array(1)
+    }, isGlobal, leftName, true, 'i16');
+  }
+
+  // set type for local
+  out.push(...typeSwitch(scope, getNodeType(scope, decl.right), {
+    [TYPES._array]: [
+      ...setType(scope, leftName, TYPES.number),
+
+      [ Opcodes.loop, Blocktype.void ],
+
+      [ Opcodes.local_get, pointer ],
+      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+
+      [ Opcodes.block, Blocktype.void ],
+      [ Opcodes.block, Blocktype.void ],
+      ...generate(scope, decl.body),
+      [ Opcodes.end ],
+
+      // increment iter pointer by valtype size
+      [ Opcodes.local_get, pointer ],
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_set, pointer ],
+
+      // increment counter by 1
+      [ Opcodes.local_get, counter ],
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_tee, counter ],
+
+      // loop if counter != length
+      [ Opcodes.local_get, length ],
+      [ Opcodes.i32_ne ],
+      [ Opcodes.br_if, 1 ],
+
+      [ Opcodes.end ],
+      [ Opcodes.end ]
+    ],
+    [TYPES.string]: [
+      ...setType(scope, leftName, TYPES.string),
+
+      [ Opcodes.loop, Blocktype.void ],
+
+      // setup new/out array
+      ...newOut,
+      [ Opcodes.drop ],
+
+      ...number(0, Valtype.i32), // base 0 for store after
+
+      // load current string ind {arg}
+      [ Opcodes.local_get, pointer ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      // store to new string ind 0
+      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+      // return new string (page)
+      ...number(newPointer),
+
+      [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+
+      [ Opcodes.block, Blocktype.void ],
+      [ Opcodes.block, Blocktype.void ],
+      ...generate(scope, decl.body),
+      [ Opcodes.end ],
+
+      // increment iter pointer by valtype size
+      [ Opcodes.local_get, pointer ],
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_set, pointer ],
+
+      // increment counter by 1
+      [ Opcodes.local_get, counter ],
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_tee, counter ],
+
+      // loop if counter != length
+      [ Opcodes.local_get, length ],
+      [ Opcodes.i32_ne ],
+      [ Opcodes.br_if, 1 ],
+
+      [ Opcodes.end ],
+      [ Opcodes.end ]
+    ],
+    default: internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`)
+  }, Blocktype.void));
+
+  depth.pop();
+  depth.pop();
+  depth.pop();
+
+  return out;
+};
+
 const getNearestLoop = () => {
   for (let i = depth.length - 1; i >= 0; i--) {
-    if (depth[i] === 'while' || depth[i] === 'for') return i;
+    if (depth[i] === 'while' || depth[i] === 'for' || depth[i] === 'forof') return i;
   }
 
   return -1;
@@ -1508,13 +2329,25 @@ const generateAssignPat = (scope, decl) => {
 };
 
 let pages = new Map();
-const allocPage = reason => {
-  if (pages.has(reason)) return pages.get(reason);
+const allocPage = (reason, type) => {
+  if (pages.has(reason)) return pages.get(reason).ind;
+
+  if (reason.startsWith('array:')) pages.hasArray = true;
+  if (reason.startsWith('string:')) pages.hasString = true;
+
+  const ind = pages.size;
+  pages.set(reason, { ind, type });
+
+  if (allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason} (type: ${type})`);
+
+  return ind;
+};
 
-  let ind = pages.size;
-  pages.set(reason, ind);
+const freePage = reason => {
+  const { ind } = pages.get(reason);
+  pages.delete(reason);
 
-  if (codeLog) log('codegen', `allocated new page of memory (${ind}) | ${reason}`);
+  if (allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
 
   return ind;
 };
@@ -1528,7 +2361,7 @@ const itemTypeToValtype = {
   i16: 'i32'
 };
 
-const storeOps = {
+const StoreOps = {
   i32: Opcodes.i32_store,
   i64: Opcodes.i64_store,
   f64: Opcodes.f64_store,
@@ -1537,13 +2370,32 @@ const storeOps = {
   i16: Opcodes.i32_store16
 };
 
+let data = [];
+
+const compileBytes = (val, itemType, signed = true) => {
+  // todo: this is a mess and needs confirming / ????
+  switch (itemType) {
+    case 'i8': return [ val % 256 ];
+    case 'i16': return [ val % 256, Math.floor(val / 256) ];
+
+    case 'i32':
+    case 'i64':
+      return enforceFourBytes(signedLEB128(val));
+
+    case 'f64': return ieee754_binary64(val);
+  }
+};
+
 const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false, itemType = valtype) => {
   const out = [];
 
+  let firstAssign = false;
   if (!arrays.has(name) || name === '$undeclared') {
+    firstAssign = true;
+
     // todo: can we just have 1 undeclared array? probably not? but this is not really memory efficient
     const uniqueName = name === '$undeclared' ? name + Math.random().toString().slice(2) : name;
-    arrays.set(name, allocPage(`${itemType === 'i16' ? 'string' : 'array'}: ${uniqueName}`) * pageSize);
+    arrays.set(name, allocPage(`${itemType === 'i16' ? 'string' : 'array'}: ${uniqueName}`, itemType) * pageSize);
   }
 
   const pointer = arrays.get(name);
@@ -1551,8 +2403,29 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   const useRawElements = !!decl.rawElements;
   const elements = useRawElements ? decl.rawElements : decl.elements;
 
+  const valtype = itemTypeToValtype[itemType];
   const length = elements.length;
 
+  if (firstAssign && useRawElements) {
+    let bytes = compileBytes(length, 'i32');
+
+    if (!initEmpty) for (let i = 0; i < length; i++) {
+      if (elements[i] == null) continue;
+
+      bytes.push(...compileBytes(elements[i], itemType));
+    }
+
+    data.push({
+      offset: pointer,
+      bytes
+    });
+
+    // local value as pointer
+    out.push(...number(pointer));
+
+    return [ out, pointer ];
+  }
+
   // store length as 0th array
   out.push(
     ...number(0, Valtype.i32),
@@ -1560,8 +2433,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ]
   );
 
-  const storeOp = storeOps[itemType];
-  const valtype = itemTypeToValtype[itemType];
+  const storeOp = StoreOps[itemType];
 
   if (!initEmpty) for (let i = 0; i < length; i++) {
     if (elements[i] == null) continue;
@@ -1576,30 +2448,34 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   // local value as pointer
   out.push(...number(pointer));
 
-  scope.memory = true;
+  return [ out, pointer ];
+};
 
-  return out;
+const makeString = (scope, str, global = false, name = '$undeclared') => {
+  const rawElements = new Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    rawElements[i] = str.charCodeAt(i);
+  }
+
+  return makeArray(scope, {
+    rawElements
+  }, global, name, false, 'i16')[0];
 };
 
 let arrays = new Map();
 const generateArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false) => {
-  return makeArray(scope, decl, global, name, initEmpty, valtype);
+  return makeArray(scope, decl, global, name, initEmpty, valtype)[0];
 };
 
 export const generateMember = (scope, decl, _global, _name) => {
-  const type = getNodeType(scope, decl.object);
+  const name = decl.object.name;
+  const pointer = arrays.get(name);
+
+  const aotPointer = pointer != null;
 
   // hack: .length
   if (decl.property.name === 'length') {
     // if (![TYPES._array, TYPES.string].includes(type)) return number(UNDEFINED);
-
-    const name = decl.object.name;
-    const pointer = arrays.get(name);
-
-    scope.memory = true;
-
-    const aotPointer = pointer != null;
-
     return [
       ...(aotPointer ? number(0, Valtype.i32) : [
         ...generate(scope, decl.object),
@@ -1611,18 +2487,17 @@ export const generateMember = (scope, decl, _global, _name) => {
     ];
   }
 
-  // this is just for arr[ind] for now. objects are partially supported via object hack (a.b -> __a_b)
-  if (![TYPES._array, TYPES.string].includes(type)) return todo(`computed member expression for objects are not supported yet`);
-
-  const name = decl.object.name;
-  const pointer = arrays.get(name);
-
-  scope.memory = true;
-
-  const aotPointer = pointer != null;
+  // // 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;
+  if (pages.hasString) {
+    0, [ newOut, newPointer ] = makeArray(scope, {
+      rawElements: new Array(1)
+    }, _global, _name, true, 'i16');
+  }
 
-  if (type === TYPES._array) {
-    return [
+  return typeSwitch(scope, getNodeType(scope, decl.object), {
+    [TYPES._array]: [
       // get index as valtype
       ...generate(scope, decl.property),
 
@@ -1638,45 +2513,46 @@ export const generateMember = (scope, decl, _global, _name) => {
       ]),
 
       // read from memory
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
-    ];
-  }
+      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
-  // string
+      ...number(TYPES.number, Valtype.i32),
+      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+    ],
 
-  const newOut = makeArray(scope, {
-    rawElements: new Array(1)
-  }, _global, _name, true, 'i16');
-  const newPointer = arrays.get(_name ?? '$undeclared');
+    [TYPES.string]: [
+      // setup new/out array
+      ...newOut,
+      [ Opcodes.drop ],
 
-  return [
-    // setup new/out array
-    ...newOut,
-    [ Opcodes.drop ],
+      ...number(0, Valtype.i32), // base 0 for store later
 
-    ...number(0, Valtype.i32), // base 0 for store later
+      ...generate(scope, decl.property),
 
-    ...generate(scope, decl.property),
+      Opcodes.i32_to_u,
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_mul ],
 
-    Opcodes.i32_to_u,
-    ...number(ValtypeSize.i16, Valtype.i32),
-    [ Opcodes.i32_mul ],
+      ...(aotPointer ? [] : [
+        ...generate(scope, decl.object),
+        Opcodes.i32_to_u,
+        [ Opcodes.i32_add ]
+      ]),
 
-    ...(aotPointer ? [] : [
-      ...generate(scope, decl.object),
-      Opcodes.i32_to_u,
-      [ Opcodes.i32_add ]
-    ]),
+      // load current string ind {arg}
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
-    // load current string ind {arg}
-    [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
+      // store to new string ind 0
+      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
 
-    // store to new string ind 0
-    [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+      // return new string (page)
+      ...number(newPointer),
 
-    // return new string (page)
-    ...number(newPointer)
-  ];
+      ...number(TYPES.string, Valtype.i32),
+      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+    ],
+
+    default: [ [ Opcodes.unreachable ] ]
+  });
 };
 
 const randId = () => Math.random().toString(16).slice(0, -4);
@@ -1728,15 +2604,14 @@ const generateFunc = (scope, decl) => {
   const innerScope = {
     locals: {},
     localInd: 0,
-    returns: [ valtypeBinary ],
-    memory: false,
+    // value, type
+    returns: [ valtypeBinary, Valtype.i32 ],
     throws: false,
     name
   };
 
   for (let i = 0; i < params.length; i++) {
-    const param = params[i];
-    innerScope.locals[param] = { idx: innerScope.localInd++, type: valtypeBinary };
+    allocVar(innerScope, params[i], false);
   }
 
   let body = objectHack(decl.body);
@@ -1751,11 +2626,9 @@ const generateFunc = (scope, decl) => {
   const wasm = generate(innerScope, body);
   const func = {
     name,
-    params: Object.values(innerScope.locals).slice(0, params.length).map(x => x.type),
+    params: Object.values(innerScope.locals).slice(0, params.length * 2).map(x => x.type),
     returns: innerScope.returns,
-    returnType: innerScope.returnType ?? TYPES.number,
     locals: innerScope.locals,
-    memory: innerScope.memory,
     throws: innerScope.throws,
     index: currentFuncIndex++
   };
@@ -1768,8 +2641,13 @@ const generateFunc = (scope, decl) => {
     }
   }
 
-  if (name !== 'main' && func.returns.length !== 0 && wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
-    wasm.push(...number(0), [ Opcodes.return ]);
+  // add end return if not found
+  if (name !== 'main' && wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
+    wasm.push(
+      ...number(0),
+      ...number(TYPES.undefined, Valtype.i32),
+      [ Opcodes.return ]
+    );
   }
 
   // change v128 params into many <type> (i32x4 -> i32/etc) instead as unsupported param valtype
@@ -1780,9 +2658,7 @@ const generateFunc = (scope, decl) => {
     if (local.type === Valtype.v128) {
       vecParams++;
 
-      /* func.memory = true; // mark func as using memory
-
-      wasm.unshift( // add v128 load for param
+      /* wasm.unshift( // add v128 load for param
         [ Opcodes.i32_const, 0 ],
         [ ...Opcodes.v128_load, 0, i * 16 ],
         [ Opcodes.local_set, local.idx ]
@@ -1893,10 +2769,10 @@ const generateFunc = (scope, decl) => {
 };
 
 const generateCode = (scope, decl) => {
-  const out = [];
+  let out = [];
 
   for (const x of decl.body) {
-    out.push(...generate(scope, x));
+    out = out.concat(generate(scope, x));
   }
 
   return out;
@@ -1912,10 +2788,9 @@ const internalConstrs = {
 
       // new Array(n)
 
-      makeArray(scope, {
+      const [ , pointer ] = makeArray(scope, {
         rawElements: new Array(0)
       }, global, name, true);
-      const pointer = arrays.get(name ?? '$undeclared');
 
       const arg = decl.arguments[0] ?? DEFAULT_VALUE;
 
@@ -1933,9 +2808,38 @@ const internalConstrs = {
       ];
     },
     type: TYPES._array
+  },
+
+  __Array_of: {
+    // this is not a constructor but best fits internal structure here
+    generate: (scope, decl, global, name) => {
+      // Array.of(i0, i1, ...)
+      return generateArray(scope, {
+        elements: decl.arguments
+      }, global, name);
+    },
+    type: TYPES._array,
+    notConstr: true
   }
 };
 
+// const _ = Array.prototype.push;
+// Array.prototype.push = function (a) {
+//   const check = arr => {
+//     for (const x of arr) {
+//       if (x === undefined) {
+//         console.trace(arr);
+//         process.exit();
+//       }
+//       if (Array.isArray(x)) check(x);
+//     }
+//   };
+//   if (Array.isArray(a) && !new Error().stack.includes('node:')) check(a);
+//   // if (Array.isArray(a)) check(a);
+
+//   return _.apply(this, arguments);
+// };
+
 export default program => {
   globals = {};
   globalInd = 0;
@@ -1944,9 +2848,9 @@ export default program => {
   funcs = [];
   funcIndex = {};
   depth = [];
-  typeStates = {};
   arrays = new Map();
   pages = new Map();
+  data = [];
   currentFuncIndex = importedFuncs.length;
 
   globalThis.valtype = 'f64';
@@ -1996,18 +2900,20 @@ export default program => {
     body: program.body
   };
 
+  if (process.argv.includes('-ast-log')) console.log(program.body.body);
+
   generateFunc(scope, program);
 
   const main = funcs[funcs.length - 1];
   main.export = true;
-  main.returns = [ valtypeBinary ];
+  main.returns = [ valtypeBinary, Valtype.i32 ];
 
   const lastInst = main.wasm[main.wasm.length - 1] ?? [ Opcodes.end ];
   if (lastInst[0] === Opcodes.drop) {
     main.wasm.splice(main.wasm.length - 1, 1);
 
     const finalStatement = program.body.body[program.body.body.length - 1];
-    main.returnType = getNodeType(main, finalStatement);
+    main.wasm.push(...getNodeType(main, finalStatement));
   }
 
   if (lastInst[0] === Opcodes.end || lastInst[0] === Opcodes.local_set || lastInst[0] === Opcodes.global_set) {
@@ -2023,5 +2929,5 @@ export default program => {
   // if blank main func and other exports, remove it
   if (main.wasm.length === 0 && funcs.reduce((acc, x) => acc + (x.export ? 1 : 0), 0) > 1) funcs.splice(funcs.length - 1, 1);
 
-  return { funcs, globals, tags, exceptions, pages };
+  return { funcs, globals, tags, exceptions, pages, data };
 };