porffor 0.0.0-bddcdc3 → 0.0.0-e6047ea

package/compiler/codeGen.js

@@ -5,6 +5,7 @@ import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from "./bui
 import { PrototypeFuncs } from "./prototype.js";
 import { number, i32x4 } 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,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);
@@ -144,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`);
+
+            if (!Array.isArray(inst)) inst = [ inst ];
+            const immediates = asm.slice(1).map(x => parseInt(x));
+
+            out.push([ ...inst, ...immediates ]);
+          }
+
+          return out;
+        },
 
-        let inst = Opcodes[asm[0].replace('.', '_')];
-        if (!inst) throw new Error(`inline asm: inst ${asm[0]} not found`);
+        __internal_print_type: str => {
+          const type = getType(scope, str) - TYPES.number;
 
-        if (!Array.isArray(inst)) inst = [ inst ];
-        const immediates = asm.slice(1).map(x => parseInt(x));
+          return [
+            ...number(type),
+            [ Opcodes.call, importedFuncs.print ],
 
-        out.push([ ...inst, ...immediates ]);
+            // newline
+            ...number(10),
+            [ Opcodes.call, importedFuncs.printChar ]
+          ];
+        }
       }
 
-      return out;
+      const name = decl.tag.name;
+      // hack for inline asm
+      if (!funcs[name]) return todo('tagged template expressions not implemented');
+
+      const str = decl.quasi.quasis[0].value.raw;
+      return funcs[name](str);
+    }
 
     default:
       return todo(`no generation for ${decl.type}!`);
@@ -281,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),
@@ -298,11 +326,11 @@ const localTmp = (scope, name, type = valtypeBinary) => {
   return idx;
 };
 
-const performLogicOp = (scope, op, left, right) => {
+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`);
@@ -313,7 +341,8 @@ const performLogicOp = (scope, op, left, right) => {
   return [
     ...left,
     [ Opcodes.local_tee, localTmp(scope, 'logictmp') ],
-    ...checks[op],
+    ...checks[op](scope, [], leftType),
+    Opcodes.i32_to,
     [ Opcodes.if, valtypeBinary ],
     ...right,
     [ Opcodes.else ],
@@ -328,8 +357,6 @@ 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 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);
@@ -464,8 +491,6 @@ const compareStrings = (scope, left, right) => {
   // 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 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);
@@ -563,75 +588,100 @@ const compareStrings = (scope, left, right) => {
   ];
 };
 
-const falsy = (scope, wasm, type) => {
+const truthy = (scope, wasm, type) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
     [ Opcodes.drop ],
-    number(0)
+    ...number(1)
   ];
 
   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 ],
+      // if length != 0
+      /* [ Opcodes.i32_eqz ],
+      [ Opcodes.i32_eqz ], */
       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) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
     [ Opcodes.drop ],
-    number(1)
+    ...number(0)
   ];
 
   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 ], */
+      // if length == 0
+      [ Opcodes.i32_eqz ],
       Opcodes.i32_from_u
     ]
   }
 
-  // if != 0
+  // if = 0
   return [
     ...wasm,
 
-    /* Opcodes.eqz,
-    [ Opcodes.i32_eqz ],
-    Opcodes.i32_from */
+    ...Opcodes.eqz,
+    Opcodes.i32_from_u
+  ];
+};
+
+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
+  return [
+    ...wasm,
+    [ Opcodes.drop ],
+    ...number(0)
   ];
 };
 
 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'));
@@ -703,21 +753,15 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
   ];
 };
 
-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;
 
@@ -753,7 +797,6 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     returns,
     returnType: TYPES[returnType ?? 'number'],
     wasm,
-    memory,
     internal: true,
     index: currentFuncIndex++
   };
@@ -772,7 +815,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 = {
@@ -786,7 +829,8 @@ const TYPES = {
   bigint: 0xffffffffffff7,
 
   // these are not "typeof" types but tracked internally
-  _array: 0xffffffffffff8
+  _array: 0xfffffffffff0f,
+  _regexp: 0xfffffffffff1f
 };
 
 const TYPE_NAMES = {
@@ -821,6 +865,8 @@ 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];
   }
 
@@ -854,6 +900,11 @@ 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;
@@ -897,6 +948,11 @@ const getNodeType = (scope, node) => {
 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);
@@ -936,7 +992,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++;
@@ -957,6 +1014,8 @@ const countLeftover = wasm => {
           } else count--;
           if (func) count += func.returns.length;
         } else count--;
+
+    // console.log(count, decompile([ inst ]).slice(0, -1));
   }
 
   return count;
@@ -1040,7 +1099,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('_');
@@ -1055,6 +1114,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;
@@ -1063,11 +1141,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) {
@@ -1075,7 +1178,7 @@ const generateCall = (scope, decl, _global, _name) => {
       if (codeLog) log('codegen', 'cloning unknown dynamic pointer');
 
       // register array
-      const [ , pointer ] = makeArray(scope, {
+      0, [ , pointer ] = makeArray(scope, {
         rawElements: new Array(0)
       }, _global, baseName, true, baseType === TYPES.string ? 'i16' : valtype);
 
@@ -1173,7 +1276,6 @@ 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) {
@@ -1189,7 +1291,7 @@ 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 (!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);
 };
@@ -1297,8 +1399,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');
@@ -1319,6 +1419,47 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
+  if (decl.left.type === 'MemberExpression' && decl.left.computed) {
+    // arr[i] | str[i]
+    const name = decl.left.object.name;
+    const pointer = arrays.get(name);
+
+    const aotPointer = pointer != null;
+
+    const newValueTmp = localTmp(scope, '__member_setter_tmp');
+
+    const parentType = getNodeType(scope, decl.left.object);
+
+    const op = decl.operator.slice(0, -1);
+    return [
+      ...(aotPointer ? number(0, Valtype.i32) : [
+        ...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 ],
+      [ Opcodes.i32_add ],
+
+      ...(op === '' ? generate(scope, decl.right, false, name) : performOp(scope, op, generate(scope, decl.left), 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) {
@@ -1339,8 +1480,10 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
+  typeStates[name] = getNodeType(scope, decl.right);
+
   if (decl.operator === '=') {
-    typeStates[name] = getNodeType(scope, decl.right);
+    // typeStates[name] = getNodeType(scope, decl.right);
 
     return [
       ...generate(scope, decl.right, isGlobal, name),
@@ -1349,8 +1492,27 @@ 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
+    // 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 ]
   ];
@@ -1377,13 +1539,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
       ];
@@ -1464,7 +1627,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');
@@ -1557,18 +1720,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
+  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;
 };
@@ -1659,13 +1910,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;
 };
@@ -1679,7 +1939,7 @@ const itemTypeToValtype = {
   i16: 'i32'
 };
 
-const storeOps = {
+const StoreOps = {
   i32: Opcodes.i32_store,
   i64: Opcodes.i64_store,
   f64: Opcodes.f64_store,
@@ -1694,7 +1954,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   if (!arrays.has(name) || name === '$undeclared') {
     // 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);
@@ -1711,7 +1971,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 storeOp = StoreOps[itemType];
   const valtype = itemTypeToValtype[itemType];
 
   if (!initEmpty) for (let i = 0; i < length; i++) {
@@ -1727,8 +1987,6 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   // local value as pointer
   out.push(...number(pointer));
 
-  scope.memory = true;
-
   return [ out, pointer ];
 };
 
@@ -1747,8 +2005,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 [
@@ -1768,8 +2024,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) {
@@ -1879,7 +2133,7 @@ const generateFunc = (scope, decl) => {
     locals: {},
     localInd: 0,
     returns: [ valtypeBinary ],
-    memory: false,
+    returnType: null,
     throws: false,
     name
   };
@@ -1905,7 +2159,6 @@ const generateFunc = (scope, decl) => {
     returns: innerScope.returns,
     returnType: innerScope.returnType,
     locals: innerScope.locals,
-    memory: innerScope.memory,
     throws: innerScope.throws,
     index: currentFuncIndex++
   };
@@ -1920,6 +2173,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
@@ -1930,9 +2185,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 ]