porffor 0.0.0-8c0bdaa → 0.0.0-a2afb57

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;
@@ -35,7 +36,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 +109,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 +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') {
-          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`);
 
-        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 ]);
+          }
 
-        if (!Array.isArray(inst)) inst = [ inst ];
-        const immediates = asm.slice(1).map(x => parseInt(x));
+          return out;
+        },
 
-        out.push([ ...inst, ...immediates ]);
+        __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,7 +309,7 @@ const generateReturn = (scope, decl) => {
     ];
   }
 
-  if (!scope.returnType) scope.returnType = getNodeType(scope, decl.argument);
+  scope.returnType = getNodeType(scope, decl.argument);
 
   return [
     ...generate(scope, decl.argument),
@@ -295,11 +326,13 @@ const localTmp = (scope, name, type = valtypeBinary) => {
   return idx;
 };
 
-const performLogicOp = (scope, op, left, right) => {
+const isIntOp = 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,10 +340,37 @@ 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),
+      [ Opcodes.if, Valtype.i32 ],
+      ...right,
+      [ Opcodes.else ],
+      [ Opcodes.local_get, localTmp(scope, 'logictmpi', Valtype.i32) ],
+      [ Opcodes.end ],
+      Opcodes.i32_from
+    ];
+  }
+
   return [
     ...left,
     [ Opcodes.local_tee, localTmp(scope, 'logictmp') ],
-    ...checks[op],
+    ...checks[op](scope, [], leftType),
+    Opcodes.i32_to,
     [ Opcodes.if, valtypeBinary ],
     ...right,
     [ Opcodes.else ],
@@ -325,15 +385,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 +445,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,89 +516,259 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   ];
 };
 
-const falsy = (scope, wasm, type) => {
+const compareStrings = (scope, left, right) => {
+  // todo: this should be rewritten into a built-in/func: String.prototype.concat
+  // 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?
+
+  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);
+
+  const index = localTmp(scope, 'compare_index', Valtype.i32);
+  const indexEnd = localTmp(scope, 'compare_index_end', Valtype.i32);
+
+  return [
+    // setup left
+    ...left,
+    Opcodes.i32_to_u,
+    [ Opcodes.local_tee, leftPointer ],
+
+    // 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?
+
+    // 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, int = false) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
     [ Opcodes.drop ],
-    number(0)
+    ...number(1, int ? Valtype.i32 : valtypeBinary)
   ];
 
   if (type === TYPES.string) {
-    // if "" (length = 0)
+    // 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_from_u
-    ]
+      // if length != 0
+      /* [ Opcodes.i32_eqz ],
+      [ Opcodes.i32_eqz ], */
+      ...(int ? [] : [ Opcodes.i32_from_u ])
+    ];
   }
 
-  // if = 0
+  // if != 0
   return [
     ...wasm,
 
-    ...Opcodes.eqz,
-    Opcodes.i32_from_u
+    /* Opcodes.eqz,
+    [ Opcodes.i32_eqz ],
+    Opcodes.i32_from */
   ];
 };
 
-const truthy = (scope, wasm, type) => {
+const falsy = (scope, wasm, type, int = false) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
     [ Opcodes.drop ],
-    number(1)
+    ...number(0, int ? Valtype.i32 : valtypeBinary)
   ];
 
   if (type === TYPES.string) {
-    // if not "" (length = 0)
+    // 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_eqz ], */
-      Opcodes.i32_from_u
+      // if length == 0
+      [ Opcodes.i32_eqz ],
+      ...(int ? [] : [ Opcodes.i32_from_u ])
     ]
   }
 
-  // if != 0
+  // if = 0
   return [
     ...wasm,
 
-    /* Opcodes.eqz,
-    [ Opcodes.i32_eqz ],
-    Opcodes.i32_from */
+    ...(int ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz, Opcodes.i32_from_u ])
+  ];
+};
+
+const nullish = (scope, wasm, type, int = false) => {
+  // undefined
+  if (type === TYPES.undefined) return [
+    ...wasm,
+    [ Opcodes.drop ],
+    ...number(1, int ? Valtype.i32 : valtypeBinary)
+  ];
+
+  // null (if object and = "0")
+  if (type === TYPES.object) return [
+    ...wasm,
+    ...(int ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz, Opcodes.i32_from_u ])
+  ];
+
+  // not
+  return [
+    ...wasm,
+    [ Opcodes.drop ],
+    ...number(0, int ? Valtype.i32 : valtypeBinary)
   ];
 };
 
-const performOp = (scope, op, left, right, leftType, rightType, _global = false, _name = '$unspecified', assign = false) => {
+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);
   }
 
+  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 (leftType && rightType && (
+    // if strict (in)equal and known types mismatch, return false (===)/true (!==)
+    ((op === '===' || op === '!==') && leftType !== rightType) ||
+
+    // if equality op and an operand is undefined, return false
+    (eqOp && leftType === TYPES.undefined ^ rightType === TYPES.undefined)
+  )) {
+    // undefined == null
+    if (((leftType === TYPES.undefined && rightType === TYPES.object) || (leftType === TYPES.object && rightType === TYPES.undefined)) && (op === '==' || op === '!=')) return [
+      ...(leftType === TYPES.object ? left : right),
+      ...Opcodes.eqz,
+      ...(op === '!=' ? [ [ Opcodes.i32_eqz ] ] : [])
+    ];
+
+    return [
+      ...left,
+      [ Opcodes.drop ],
+
+      ...right,
+      [ Opcodes.drop ],
+
+      // return true (!=/!==) or false (else)
+      ...number(op === '!=' || op === '!==' ? 1 : 0, Valtype.i32)
+    ];
+  }
+
+  // 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);
     }
 
-    // any other math op, NaN
-    if (!['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op)) return number(NaN);
+    // not an equality op, NaN
+    if (!eqOp) return number(NaN);
 
     // else leave bool ops
-    // todo: convert string to number if string and number or le/ge op
-    // todo: string equality
+    // todo: convert string to number if string and number/bool
+    // todo: string (>|>=|<|<=) string
+
+    // string comparison
+    if (op === '===' || op === '==') {
+      return compareStrings(scope, left, right);
+    }
+
+    if (op === '!==' || op === '!=') {
+      return [
+        ...compareStrings(scope, left, right),
+        [ Opcodes.i32_eqz ]
+      ];
+    }
   }
 
   let ops = operatorOpcode[valtype][op];
@@ -570,16 +798,14 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 };
 
 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 +841,6 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     returns,
     returnType: TYPES[returnType ?? 'number'],
     wasm,
-    memory,
     internal: true,
     index: currentFuncIndex++
   };
@@ -634,7 +859,7 @@ 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));
 };
 
 const TYPES = {
@@ -648,7 +873,8 @@ const TYPES = {
   bigint: 0xffffffffffff7,
 
   // these are not "typeof" types but tracked internally
-  _array: 0xffffffffffff8
+  _array: 0xfffffffffff0f,
+  _regexp: 0xfffffffffff1f
 };
 
 const TYPE_NAMES = {
@@ -682,6 +908,9 @@ const getType = (scope, _name) => {
 
 const getNodeType = (scope, node) => {
   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;
+
     return TYPES[typeof node.value];
   }
 
@@ -696,7 +925,7 @@ const getNodeType = (scope, node) => {
   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 (func) return func.returnType;
 
     if (builtinFuncs[name]) return TYPES[builtinFuncs[name].returnType ?? 'number'];
     if (internalConstrs[name]) return internalConstrs[name].type;
@@ -715,15 +944,18 @@ const getNodeType = (scope, node) => {
 
     // 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 ?? TYPES.number;
-
-    return TYPES.number;
+    if (protoFunc) return protoFunc.returnType;
   }
 
   if (node.type === 'ExpressionStatement') {
@@ -755,14 +987,16 @@ const getNodeType = (scope, node) => {
 
     if (objectType === TYPES.string && node.computed) return TYPES.string;
   }
-
-  // default to number
-  return TYPES.number;
 };
 
 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);
@@ -784,15 +1018,41 @@ const generateLiteral = (scope, decl, global, name) => {
         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');
+      }, global, name, false, 'i16')[0];
 
     default:
       return todo(`cannot generate literal of type ${typeof decl.value}`);
@@ -802,7 +1062,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++;
@@ -823,6 +1084,8 @@ const countLeftover = wasm => {
           } else count--;
           if (func) count += func.returns.length;
         } else count--;
+
+    // console.log(count, decompile([ inst ]).slice(0, -1));
   }
 
   return count;
@@ -906,7 +1169,7 @@ const generateCall = (scope, decl, _global, _name) => {
   }
 
   let out = [];
-  let protoFunc, protoName, baseType, baseName = '$undeclared';
+  let protoFunc, protoName, baseType, baseName;
   // ident.func()
   if (name && name.startsWith('__')) {
     const spl = name.slice(2).split('_');
@@ -921,6 +1184,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;
@@ -929,11 +1211,36 @@ const generateCall = (scope, decl, _global, _name) => {
 
     out = generate(scope, decl.callee.object);
     out.push([ Opcodes.drop ]);
+
+    baseName = [...arrays.keys()].pop();
   }
 
-  if (protoFunc) {
-    scope.memory = true;
+  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);
 
     if (pointer == null) {
@@ -941,10 +1248,9 @@ const generateCall = (scope, decl, _global, _name) => {
       if (codeLog) log('codegen', 'cloning unknown dynamic pointer');
 
       // register array
-      makeArray(scope, {
+      0, [ , pointer ] = makeArray(scope, {
         rawElements: new Array(0)
       }, _global, baseName, true, baseType === TYPES.string ? 'i16' : valtype);
-      pointer = arrays.get(baseName);
 
       const [ local, isGlobal ] = lookupName(scope, baseName);
 
@@ -962,29 +1268,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) => {
-        const out = makeArray(scope, {
-          rawElements: new Array(length)
-        }, _global, _name, true, itemType);
-        return [ out, arrays.get(_name ?? '$undeclared') ];
-      }),
+      ...protoOut,
       [ Opcodes.end ]
     ];
   }
@@ -1041,11 +1357,10 @@ const generateCall = (scope, decl, _global, _name) => {
     args = args.slice(0, func.params.length);
   }
 
-  if (func && func.memory) scope.memory = true;
   if (func && func.throws) scope.throws = true;
 
   for (const arg of args) {
-    out.push(...generate(scope, arg));
+    out = out.concat(generate(scope, arg));
   }
 
   out.push([ Opcodes.call, idx ]);
@@ -1056,8 +1371,8 @@ const generateCall = (scope, decl, _global, _name) => {
 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);
 };
@@ -1074,12 +1389,12 @@ const unhackName = name => {
 };
 
 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) {
@@ -1116,7 +1431,7 @@ const generateVar = (scope, decl) => {
 
     // x.init ??= DEFAULT_VALUE;
     if (x.init) {
-      out.push(...generate(scope, x.init, global, name));
+      out = out.concat(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) {
@@ -1165,8 +1480,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');
@@ -1187,13 +1500,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`)
@@ -1202,13 +1562,15 @@ 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);
+  typeStates[name] = getNodeType(scope, decl.right);
+
+  if (op === '=') {
+    // typeStates[name] = getNodeType(scope, decl.right);
 
     return [
       ...generate(scope, decl.right, isGlobal, name),
@@ -1217,8 +1579,26 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
+  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 ]
+    ];
+  }
+
   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 ]
   ];
@@ -1245,13 +1625,14 @@ const generateUnary = (scope, decl) => {
 
     case '!':
       // !=
-      return falsy(scope, generate(scope, decl.argument));
+      return falsy(scope, generate(scope, decl.argument), getNodeType(scope, decl.argument));
 
     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,7 +1670,7 @@ const generateUnary = (scope, decl) => {
       return out;
 
     case 'typeof':
-      const type = getNodeType(scope, decl.argument);
+      const type = getNodeType(scope, decl.argument) ?? TYPES.number;
 
       // for custom types, just return object
       if (type > 0xffffffffffff7) return number(TYPES.object);
@@ -1332,7 +1713,7 @@ 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));
 
   out.push(Opcodes.i32_to, [ Opcodes.if, Blocktype.void ]);
   depth.push('if');
@@ -1422,9 +1803,116 @@ const generateWhile = (scope, decl) => {
   return out;
 };
 
+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('forof');
+
+  // setup local for left
+  generate(scope, decl.left);
+
+  const leftName = decl.left.declarations[0].id.name;
+
+  // set type for local
+  typeStates[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;
+};
+
 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 +1996,22 @@ 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;
+
+  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 +2025,7 @@ const itemTypeToValtype = {
   i16: 'i32'
 };
 
-const storeOps = {
+const StoreOps = {
   i32: Opcodes.i32_store,
   i64: Opcodes.i64_store,
   f64: Opcodes.f64_store,
@@ -1537,13 +2034,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);
@@ -1551,8 +2066,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 +2096,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,14 +2111,23 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   // local value as pointer
   out.push(...number(pointer));
 
-  scope.memory = true;
-
-  return out;
+  return [ out, pointer ];
 };
 
 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];
+};
+
+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) => {
@@ -1596,8 +2140,6 @@ export const generateMember = (scope, decl, _global, _name) => {
     const name = decl.object.name;
     const pointer = arrays.get(name);
 
-    scope.memory = true;
-
     const aotPointer = pointer != null;
 
     return [
@@ -1617,8 +2159,6 @@ export const generateMember = (scope, decl, _global, _name) => {
   const name = decl.object.name;
   const pointer = arrays.get(name);
 
-  scope.memory = true;
-
   const aotPointer = pointer != null;
 
   if (type === TYPES._array) {
@@ -1644,10 +2184,9 @@ export const generateMember = (scope, decl, _global, _name) => {
 
   // string
 
-  const newOut = makeArray(scope, {
+  const [ newOut, newPointer ] = makeArray(scope, {
     rawElements: new Array(1)
   }, _global, _name, true, 'i16');
-  const newPointer = arrays.get(_name ?? '$undeclared');
 
   return [
     // setup new/out array
@@ -1729,7 +2268,7 @@ const generateFunc = (scope, decl) => {
     locals: {},
     localInd: 0,
     returns: [ valtypeBinary ],
-    memory: false,
+    returnType: null,
     throws: false,
     name
   };
@@ -1753,9 +2292,8 @@ const generateFunc = (scope, decl) => {
     name,
     params: Object.values(innerScope.locals).slice(0, params.length).map(x => x.type),
     returns: innerScope.returns,
-    returnType: innerScope.returnType ?? TYPES.number,
+    returnType: innerScope.returnType,
     locals: innerScope.locals,
-    memory: innerScope.memory,
     throws: innerScope.throws,
     index: currentFuncIndex++
   };
@@ -1770,6 +2308,8 @@ 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;
   }
 
   // change v128 params into many <type> (i32x4 -> i32/etc) instead as unsupported param valtype
@@ -1780,9 +2320,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 +2431,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 +2450,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,6 +2470,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
   }
 };
 
@@ -1946,7 +2495,9 @@ export default program => {
   depth = [];
   typeStates = {};
   arrays = new Map();
+  varMetadata = new Map();
   pages = new Map();
+  data = [];
   currentFuncIndex = importedFuncs.length;
 
   globalThis.valtype = 'f64';
@@ -2023,5 +2574,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 };
 };