porffor 0.0.0-425ea20 → 0.0.0-48403fd

package/compiler/codeGen.js

@@ -1,10 +1,11 @@
 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 parse from "./parse.js";
+import * as Rhemyn from "../rhemyn/compile.js";
 
 let globals = {};
 let globalInd = 0;
@@ -108,8 +109,8 @@ const generate = (scope, decl, global = false, name = undefined) => {
     case 'WhileStatement':
       return generateWhile(scope, decl);
 
-    /* case 'ForOfStatement':
-      return generateForOf(scope, decl); */
+    case 'ForOfStatement':
+      return generateForOf(scope, decl);
 
     case 'BreakStatement':
       return generateBreak(scope, decl);
@@ -151,44 +152,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') {
-          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`);
 
-        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));
 
-        if (!Array.isArray(inst)) inst = [ inst ];
-        const immediates = asm.slice(1).map(x => parseInt(x));
+            out.push([ ...inst, ...immediates ]);
+          }
 
-        out.push([ ...inst, ...immediates ]);
+          return out;
+        },
+
+        __internal_print_type: str => {
+          const type = getType(scope, str) - TYPES.number;
+
+          return [
+            ...number(type),
+            [ Opcodes.call, importedFuncs.print ],
+
+            // 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}!`);
@@ -278,19 +300,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 ]
     ];
   }
 
-  scope.returnType = getNodeType(scope, decl.argument);
-
   return [
     ...generate(scope, decl.argument),
+    ...getNodeType(scope, decl.argument),
     [ Opcodes.return ]
   ];
 };
@@ -304,6 +324,8 @@ const localTmp = (scope, name, type = valtypeBinary) => {
   return idx;
 };
 
+const isIntOp = op => op[0] >= 0xb7 && op[0] <= 0xba;
+
 const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   const checks = {
     '||': falsy,
@@ -316,15 +338,52 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   // 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](scope, [], leftType),
-    Opcodes.i32_to,
+    ...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 ]
   ];
 };
@@ -339,6 +398,9 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   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');
 
@@ -566,94 +628,106 @@ const compareStrings = (scope, left, right) => {
   ];
 };
 
-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,
-      Opcodes.i32_to_u,
-
-      // get length
-      [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-
-      // if length != 0
-      /* [ Opcodes.i32_eqz ],
-      [ Opcodes.i32_eqz ], */
-      Opcodes.i32_from_u
-    ]
-  }
-
-  // if != 0
+  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
   return [
     ...wasm,
-
-    /* Opcodes.eqz,
-    [ Opcodes.i32_eqz ],
-    Opcodes.i32_from */
+    [ Opcodes.local_set, tmp ],
+
+    ...typeSwitch(scope, type, {
+      [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: [
+        // if value != 0
+        [ Opcodes.local_get, tmp ],
+
+        // ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
+        ...(!intOut || (intIn && intOut) ? [] : [ Opcodes.i32_to_u ]),
+
+        /* Opcodes.eqz,
+        [ Opcodes.i32_eqz ],
+        Opcodes.i32_from */
+      ]
+    }, intOut ? Valtype.i32 : valtypeBinary)
   ];
 };
 
-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,
-      Opcodes.i32_to_u,
-
-      // get length
-      [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-
-      // if length == 0
-      [ Opcodes.i32_eqz ],
-      Opcodes.i32_from_u
-    ]
-  }
-
-  // if = 0
+const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
+  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
   return [
     ...wasm,
-
-    ...Opcodes.eqz,
-    Opcodes.i32_from_u
+    [ 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 ],
+        [ 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 nullish = (scope, wasm, type) => {
-  // undefined
-  if (type === TYPES.undefined) return [
-    ...wasm,
-    [ Opcodes.drop ],
-    ...number(1)
-  ];
-
-  // null (if object and = "0")
-  if (type === TYPES.object) return [
-    ...wasm,
-    ...Opcodes.eqz,
-    Opcodes.i32_from_u
-  ];
-
-  // not
+const nullish = (scope, wasm, type, intIn = false, intOut = false) => {
+  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
   return [
     ...wasm,
-    [ Opcodes.drop ],
-    ...number(0)
+    [ 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)
   ];
 };
 
@@ -662,31 +736,35 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     return performLogicOp(scope, op, left, right, leftType, rightType);
   }
 
-  if (codeLog && (!leftType || !rightType)) log('codegen', 'untracked type in op', op, _name, '\n' + new Error().stack.split('\n').slice(1).join('\n'));
+  const eqOp = ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op);
 
-  // if strict (in)equal and known types mismatch, return false (===)/true (!==)
-  if ((op === '===' || op === '!==') && leftType && rightType && leftType !== rightType) {
-    return [
-      ...left,
-      ...right,
+  const startOut = [], endOut = [];
+  const finalise = out => startOut.concat(out, endOut);
 
-      // drop values
-      [ Opcodes.drop ],
-      [ Opcodes.drop ],
+  // if strict (in)equal check types match and...
+  if (op === '===' || op === '!==') {
+    startOut.push(
+      ...leftType,
+      ...rightType,
+      [ Opcodes.i32_eq ]
+    );
 
-      // return false (===)/true (!==)
-      ...number(op === '===' ? 0 : 1, Valtype.i32)
-    ];
+    endOut.push(
+      [ Opcodes.i32_and ]
+    );
   }
 
+  // todo: if equality op and an operand is undefined, return false
+  // todo: niche null hell with 0
+
   if (leftType === TYPES.string || rightType === TYPES.string) {
     if (op === '+') {
       // string concat (a + b)
-      return concatStrings(scope, left, right, _global, _name, assign);
+      return finalise(concatStrings(scope, left, right, _global, _name, assign));
     }
 
-    // any other math op, NaN
-    if (!['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op)) return number(NaN);
+    // 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
@@ -694,14 +772,14 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 
     // string comparison
     if (op === '===' || op === '==') {
-      return compareStrings(scope, left, right);
+      return finalise(compareStrings(scope, left, right));
     }
 
     if (op === '!==' || op === '!=') {
-      return [
+      return finalise([
         ...compareStrings(scope, left, right),
         [ Opcodes.i32_eqz ]
-      ];
+      ]);
     }
   }
 
@@ -713,39 +791,33 @@ 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 ];
 
-  return [
+  return finalise([
     ...left,
     ...right,
     ops
-  ];
+  ]);
 };
 
-let binaryExpDepth = 0;
 const generateBinaryExp = (scope, decl, _global, _name) => {
-  binaryExpDepth++;
-
-  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);
 
-  binaryExpDepth--;
   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;
 
@@ -781,7 +853,6 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     returns,
     returnType: TYPES[returnType ?? 'number'],
     wasm,
-    memory,
     internal: true,
     index: currentFuncIndex++
   };
@@ -804,17 +875,18 @@ const generateLogicExp = (scope, decl) => {
 };
 
 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
 };
 
 const TYPE_NAMES = {
@@ -830,101 +902,156 @@ const TYPE_NAMES = {
   [TYPES._array]: 'Array'
 };
 
-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 setType = (scope, _name, type) => {
+  const name = mapName(_name);
+
+  const out = typeof type === 'number' ? number(type, Valtype.i32) : type;
+
+  if (scope.locals[name]) return [
+    ...out,
+    [ Opcodes.local_set, scope.locals[name + '#type'].idx ]
+  ];
+
+  if (globals[name]) return [
+    ...out,
+    [ Opcodes.global_set, globals[name + '#type'].idx ]
+  ];
+
+  throw new Error('could not find var');
+}
+
 const getNodeType = (scope, node) => {
-  if (node.type === 'Literal') {
-    if (['number', 'boolean', 'string', 'undefined', 'object', 'function', 'symbol', 'bigint'].includes(node.value)) return TYPES.number;
-    return TYPES[typeof node.value];
-  }
+  // console.trace(node);
 
-  if (isFuncType(node.type)) {
-    return TYPES.function;
-  }
+  const inner = () => {
+    if (node.type === 'Literal') {
+      // if (['number', 'boolean', 'string', 'undefined', 'object', 'function', 'symbol', 'bigint'].includes(node.value)) return TYPES.number;
+      if (node.regex) return TYPES._regexp;
 
-  if (node.type === 'Identifier') {
-    return getType(scope, node.name);
-  }
+      return TYPES[typeof node.value];
+    }
 
-  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;
+    if (isFuncType(node.type)) {
+      return TYPES.function;
+    }
+
+    if (node.type === 'Identifier') {
+      return getType(scope, node.name);
+    }
+
+    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 (scope.locals['#last_type']) return [ [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ] ];
+
+        // presume
+        // todo: warn here?
+        return TYPES.number;
+      }
 
-    if (builtinFuncs[name]) return TYPES[builtinFuncs[name].returnType ?? 'number'];
-    if (internalConstrs[name]) return internalConstrs[name].type;
+      if (builtinFuncs[name]) return TYPES[builtinFuncs[name].returnType ?? 'number'];
+      if (internalConstrs[name]) return internalConstrs[name].type;
 
-    let protoFunc;
-    // ident.func()
-    if (name && name.startsWith('__')) {
-      const spl = name.slice(2).split('_');
+      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 baseName = spl.slice(0, -1).join('_');
+        const baseType = getType(scope, baseName);
 
-      const func = spl[spl.length - 1];
-      protoFunc = prototypeFuncs[baseType]?.[func];
+        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;
     }
 
-    // literal.func()
-    if (!name && node.callee.type === 'MemberExpression') {
-      const baseType = getNodeType(scope, node.callee.object);
+    if (node.type === 'ExpressionStatement') {
+      return getNodeType(scope, node.expression);
+    }
 
-      const func = node.callee.property.name;
-      protoFunc = prototypeFuncs[baseType]?.[func];
+    if (node.type === 'AssignmentExpression') {
+      return getNodeType(scope, node.right);
     }
 
-    if (protoFunc) return protoFunc.returnType;
-  }
+    if (node.type === 'ArrayExpression') {
+      return TYPES._array;
+    }
 
-  if (node.type === 'ExpressionStatement') {
-    return getNodeType(scope, node.expression);
-  }
+    if (node.type === 'BinaryExpression') {
+      if (['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(node.operator)) return TYPES.boolean;
 
-  if (node.type === 'AssignmentExpression') {
-    return getNodeType(scope, node.right);
-  }
+      if (node.operator === '+' && (getNodeType(scope, node.left) === TYPES.string || getNodeType(scope, node.right) === TYPES.string)) return TYPES.string;
+    }
 
-  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;
+    if (node.type === 'MemberExpression') {
+      const objectType = getNodeType(scope, node.object);
 
-    if (node.operator === '+' && (getNodeType(scope, node.left) === TYPES.string || getNodeType(scope, node.right) === TYPES.string)) return TYPES.string;
-  }
+      if (objectType === TYPES.string && node.computed) return TYPES.string;
+    }
 
-  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 (scope.locals['#last_type']) return [ [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ] ];
 
-  if (node.type === 'MemberExpression') {
-    const objectType = getNodeType(scope, node.object);
+    // presume
+    // todo: warn here?
+    return TYPES.number;
+  };
 
-    if (objectType === TYPES.string && node.computed) return TYPES.string;
-  }
+  const ret = inner();
+  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);
@@ -935,23 +1062,49 @@ const generateLiteral = (scope, decl, global, name) => {
 
     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);
-      }
+      // 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 aotWFA = process.argv.includes('-aot-well-formed-string-approximation');
+      let wellFormed = aotWFA ? true : undefined;
 
       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);
+
+        if (wellFormed) {
+          // check if surrogate
+          if ((str.charCodeAt(j) & 0xF800) === 0xD800) {
+            // unpaired trailing surrogate
+            if (str.charCodeAt(j) >= 0xDC00) {
+              wellFormed = false;
+            }
+
+            // unpaired leading surrogate
+            // if (++j >= str.length || (str.charCodeAt(j) & 0xFC00) != 0xDC00) {
+            if ((str.charCodeAt(++j) & 0xFC00) != 0xDC00) {
+              wellFormed = false;
+            }
+          }
+
+          j++;
+        }
       }
 
+      // console.log(wellFormed, str);
+
+      if (aotWFA) addVarMeta(name, { wellFormed });
+
       return makeArray(scope, {
         rawElements
       }, global, name, false, 'i16')[0];
@@ -964,6 +1117,8 @@ const generateLiteral = (scope, decl, global, name) => {
 const countLeftover = wasm => {
   let count = 0, depth = 0;
 
+  // console.trace(wasm.length);
+
   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)) {
@@ -974,11 +1129,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) {
@@ -986,6 +1142,8 @@ const countLeftover = wasm => {
           } else count--;
           if (func) count += func.returns.length;
         } else count--;
+
+    // console.log(count, decompile([ inst ]).slice(0, -1));
   }
 
   return count;
@@ -997,6 +1155,13 @@ const disposeLeftover = wasm => {
   for (let i = 0; i < leftover; i++) wasm.push([ Opcodes.drop ]);
 };
 
+const disposeType = (scope, wasm) => {
+  const lastOp = wasm[wasm.length - 1];
+  if (lastOp[0] === Opcodes.i32_const || (lastOp[0] === Opcodes.local_get && lastOp[1] === scope.locals['#last_type']))
+
+  wasm.push([ Opcodes.drop ]);
+};
+
 const generateExp = (scope, decl) => {
   const expression = decl.expression;
 
@@ -1084,6 +1249,25 @@ const generateCall = (scope, decl, _global, _name) => {
 
   // literal.func()
   if (!name && decl.callee.type === 'MemberExpression') {
+    // 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
+      ];
+    }
+
     baseType = getNodeType(scope, decl.callee.object);
 
     const func = decl.callee.property.name;
@@ -1096,6 +1280,31 @@ const generateCall = (scope, decl, _global, _name) => {
     baseName = [...arrays.keys()].pop();
   }
 
+  if (protoName && baseType === TYPES.string && Rhemyn[protoName]) {
+    const func = Rhemyn[protoName](decl.arguments[0].regex.pattern, currentFuncIndex++);
+
+    funcIndex[func.name] = func.index;
+    funcs.push(func);
+
+    const pointer = arrays.get(baseName);
+    const [ local, isGlobal ] = lookupName(scope, baseName);
+
+    return [
+      ...out,
+
+      ...(pointer == null ? [
+        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+        Opcodes.i32_to_u,
+      ] : [
+        ...number(pointer, Valtype.i32)
+      ]),
+
+      // call regex func
+      [ Opcodes.call, func.index ],
+      Opcodes.i32_from
+    ];
+  }
+
   if (protoFunc) {
     let pointer = arrays.get(baseName);
 
@@ -1124,28 +1333,39 @@ const generateCall = (scope, decl, _global, _name) => {
     if (protoFunc.noArgRetLength && decl.arguments.length === 0) return arrayUtil.getLength(pointer)
 
     let protoLocal = protoFunc.local ? localTmp(scope, `__${TYPE_NAMES[baseType]}_${protoName}_tmp`, protoFunc.local) : -1;
+    let protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${TYPE_NAMES[baseType]}_${protoName}_tmp2`, protoFunc.local2) : -1;
 
     // use local for cached i32 length as commonly used
     let lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
 
+    let lengthI32CacheUsed = false;
+
+    const protoOut = protoFunc(pointer, {
+      getCachedI32: () => {
+        lengthI32CacheUsed = true;
+        return [ [ Opcodes.local_get, lengthLocal ] ]
+      },
+      setCachedI32: () => [ [ Opcodes.local_set, 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, protoLocal2, (length, itemType) => {
+      return makeArray(scope, {
+        rawElements: new Array(length)
+      }, _global, _name, true, itemType);
+    }, varMetadata.get(baseName));
+
     return [
       ...out,
 
-      ...arrayUtil.getLengthI32(pointer),
-      [ Opcodes.local_set, lengthLocal ],
+      ...(!lengthI32CacheUsed ? [] : [
+        ...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) => {
-        return makeArray(scope, {
-          rawElements: new Array(length)
-        }, _global, _name, true, itemType);
-      }),
+      ...protoOut,
       [ Opcodes.end ]
     ];
   }
@@ -1191,32 +1411,39 @@ 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.throws) scope.throws = true;
 
   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 user func, they return [ value, type ]
+  if (userFunc) 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 (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);
@@ -1233,13 +1460,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, 0 ]);
+    out.push([ Opcodes.end ]);
+  }
+
+  // default
+  if (bc.default) out.push(...bc.default);
+    else 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 global = topLevel || decl._bare; // decl.kind === 'var';
   const target = global ? globals : scope.locals;
 
   for (const x of decl.declarations) {
@@ -1260,43 +1541,13 @@ 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`);
+    let idx = allocVar(scope, name, global);
 
-      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;
+    out.push(...setType(scope, name, x.init ? getNodeType(scope, x.init) : TYPES.undefined));
 
     // x.init ??= DEFAULT_VALUE;
     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 ]);
     }
@@ -1345,13 +1596,60 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
+  const op = decl.operator.slice(0, -1) || '=';
+
+  // arr[i] | str[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);
+
+    const parentType = getNodeType(scope, decl.left.object);
+
+    return [
+      ...(aotPointer ? [] : [
+        ...generate(scope, decl.left.object),
+        Opcodes.i32_to_u
+      ]),
+
+      // get index as valtype
+      ...generate(scope, decl.left.property),
+
+      // convert to i32 and turn into byte offset by * valtypeSize (4 for i32, 8 for i64/f64)
+      Opcodes.i32_to_u,
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_mul ],
+      ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
+      ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+      ...(op === '=' ? generate(scope, decl.right, false, name) : performOp(scope, op, [
+        [ Opcodes.local_get, pointerTmp ],
+        [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+      ], generate(scope, decl.right), parentType === TYPES._array ? TYPES.number : TYPES.string, getNodeType(scope, decl.right), false, name, true)),
+      [ Opcodes.local_tee, newValueTmp ],
+
+      ...(parentType === TYPES._array ? [
+        [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+      ] : [
+        Opcodes.i32_to_u,
+        [ StoreOps.i16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+      ]),
+
+      [ 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`)
@@ -1360,14 +1658,12 @@ 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 ],
@@ -1375,7 +1671,6 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
-  const op = decl.operator.slice(0, -1);
   if (op === '||' || op === '&&' || op === '??') {
     // todo: is this needed?
     // for logical assignment ops, it is not left @= right ~= left = left @ right
@@ -1422,7 +1717,7 @@ const generateUnary = (scope, decl) => {
 
     case '!':
       // !=
-      return falsy(scope, generate(scope, decl.argument), getNodeType(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)
@@ -1467,11 +1762,16 @@ const generateUnary = (scope, decl) => {
       return out;
 
     case 'typeof':
-      const type = getNodeType(scope, decl.argument) ?? TYPES.number;
-
-      // for custom types, just return object
-      if (type > 0xffffffffffff7) return number(TYPES.object);
-      return number(type);
+      // todo: do not use typeswitch, use custom bc instead
+      // todo: _array & _regexp -> object. others when impl'd
+      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.object]: makeString(scope, 'object', false, '#typeof_result'),
+        [TYPES.function]: makeString(scope, 'function', false, '#typeof_result'),
+      });
 
     default:
       return todo(`unary operator ${decl.operator} not implemented yet`);
@@ -1510,9 +1810,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);
@@ -1541,9 +1841,21 @@ const generateConditional = (scope, decl) => {
 
   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();
 
@@ -1603,18 +1915,106 @@ const generateWhile = (scope, decl) => {
 const generateForOf = (scope, decl) => {
   const out = [];
 
+  const rightType = getNodeType(scope, decl.right);
+  const valtypeSize = rightType === TYPES._array ? ValtypeSize[valtype] : ValtypeSize.i16; // presume array (:()
+
+  // 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 ],
+
+    // get length
+    [ Opcodes.local_get, pointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+    [ Opcodes.local_set, length ]
+  );
+
   out.push([ Opcodes.loop, Blocktype.void ]);
-  depth.push('while');
+  depth.push('forof');
 
-  out.push(...generate(scope, decl.test));
-  out.push(Opcodes.i32_to, [ Opcodes.if, Blocktype.void ]);
-  depth.push('if');
+  // setup local for left
+  generate(scope, decl.left);
 
-  out.push(...generate(scope, decl.body));
+  const leftName = decl.left.declarations[0].id.name;
 
-  out.push([ Opcodes.br, 1 ]);
-  out.push([ Opcodes.end ], [ Opcodes.end ]);
-  depth.pop(); depth.pop();
+  // set type for local
+  out.push(...setType(scope, leftName, rightType === TYPES._array ? TYPES.number : TYPES.string));
+
+  const [ local, isGlobal ] = lookupName(scope, leftName);
+
+  if (rightType === TYPES._array) { // array
+    out.push(
+      [ Opcodes.local_get, pointer ],
+      [ Opcodes.load, Math.log2(valtypeSize) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+    );
+  } else { // string
+    const [ newOut, newPointer ] = makeArray(scope, {
+      rawElements: new Array(1)
+    }, isGlobal, leftName, true, 'i16');
+
+    out.push(
+      // 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)
+    );
+  }
+
+  // set left value
+  out.push([ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ]);
+
+  out.push(
+    [ Opcodes.block, Blocktype.void ],
+    [ Opcodes.block, Blocktype.void ]
+  );
+  depth.push('block');
+  depth.push('block');
+
+  out.push(
+    ...generate(scope, decl.body),
+    [ Opcodes.end ]
+  );
+  depth.pop();
+
+  out.push(
+    // increment iter pointer by valtype size
+    [ Opcodes.local_get, pointer ],
+    ...number(valtypeSize, 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 ]
+  );
+  depth.pop();
+  depth.pop();
 
   return out;
 };
@@ -1705,19 +2105,19 @@ 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;
 
-  let ind = pages.size;
-  pages.set(reason, ind);
+  const ind = pages.size;
+  pages.set(reason, { ind, type });
 
-  if (allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason}`);
+  if (allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason} (type: ${type})`);
 
   return ind;
 };
 
 const freePage = reason => {
-  let ind = pages.get(reason);
+  const { ind } = pages.get(reason);
   pages.delete(reason);
 
   if (allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
@@ -1734,7 +2134,7 @@ const itemTypeToValtype = {
   i16: 'i32'
 };
 
-const storeOps = {
+const StoreOps = {
   i32: Opcodes.i32_store,
   i64: Opcodes.i64_store,
   f64: Opcodes.f64_store,
@@ -1743,13 +2143,31 @@ const storeOps = {
   i16: Opcodes.i32_store16
 };
 
+let data = [];
+
+const compileBytes = (val, itemType, signed = true) => {
+  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);
@@ -1757,8 +2175,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),
@@ -1766,8 +2205,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;
@@ -1785,11 +2223,33 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   return [ out, pointer ];
 };
 
+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)[0];
 };
 
+let varMetadata = new Map();
+const addVarMeta = (_name, obj) => {
+  const name = _name ?? '$undeclared';
+  if (!varMetadata.has(name)) varMetadata.set(name, {});
+
+  const meta = varMetadata.get(name);
+  for (const k in obj) {
+    meta[k] = obj[k];
+  }
+};
+
 export const generateMember = (scope, decl, _global, _name) => {
   const type = getNodeType(scope, decl.object);
 
@@ -1927,16 +2387,14 @@ const generateFunc = (scope, decl) => {
   const innerScope = {
     locals: {},
     localInd: 0,
-    returns: [ valtypeBinary ],
-    returnType: null,
-    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);
@@ -1951,9 +2409,8 @@ 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,
     locals: innerScope.locals,
     throws: innerScope.throws,
     index: currentFuncIndex++
@@ -1967,10 +2424,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 ]);
-
-    if (func.returnType === null) func.returnType = TYPES.undefined;
+  // 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
@@ -2092,10 +2552,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;
@@ -2131,6 +2591,18 @@ 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
   }
 };
 
@@ -2142,9 +2614,10 @@ export default program => {
   funcs = [];
   funcIndex = {};
   depth = [];
-  typeStates = {};
   arrays = new Map();
+  varMetadata = new Map();
   pages = new Map();
+  data = [];
   currentFuncIndex = importedFuncs.length;
 
   globalThis.valtype = 'f64';
@@ -2194,18 +2667,23 @@ 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);
+    // main.wasm.splice(main.wasm.length - 2, 2);
 
     const finalStatement = program.body.body[program.body.body.length - 1];
-    main.returnType = getNodeType(main, finalStatement);
+    // 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) {
@@ -2221,5 +2699,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 };
 };