porffor 0.0.0-61de729 → 0.0.0-679c4ea

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,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));
 
-        let inst = Opcodes[asm[0].replace('.', '_')];
-        if (!inst) throw new Error(`inline asm: inst ${asm[0]} not found`);
+            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}!`);
@@ -288,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),
@@ -309,7 +330,7 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   const checks = {
     '||': falsy,
     '&&': truthy,
-    // todo: ??
+    '??': nullish
   };
 
   if (!checks[op]) return todo(`logic operator ${op} not implemented yet`);
@@ -336,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);
@@ -472,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);
@@ -575,8 +592,8 @@ const truthy = (scope, wasm, type) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
-    ...(wasm.length === 0 ? [] : [ [ Opcodes.drop ] ]),
-    number(1)
+    [ Opcodes.drop ],
+    ...number(1)
   ];
 
   if (type === TYPES.string) {
@@ -610,8 +627,8 @@ const falsy = (scope, wasm, type) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
-    ...(wasm.length === 0 ? [] : [ [ Opcodes.drop ] ]),
-    number(0)
+    [ Opcodes.drop ],
+    ...number(0)
   ];
 
   if (type === TYPES.string) {
@@ -639,6 +656,29 @@ const falsy = (scope, wasm, type) => {
   ];
 };
 
+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, leftType, rightType);
@@ -646,29 +686,44 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 
   if (codeLog && (!leftType || !rightType)) log('codegen', 'untracked type in op', op, _name, '\n' + new Error().stack.split('\n').slice(1).join('\n'));
 
-  // if strict (in)equal and known types mismatch, return false (===)/true (!==)
-  if ((op === '===' || op === '!==') && leftType && rightType && leftType !== rightType) {
+  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,
-      ...right,
-
-      // drop values
       [ Opcodes.drop ],
+
+      ...right,
       [ Opcodes.drop ],
 
-      // return false (===)/true (!==)
-      ...number(op === '===' ? 0 : 1, Valtype.i32)
+      // 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/bool
@@ -713,21 +768,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;
 
@@ -763,7 +812,6 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     returns,
     returnType: TYPES[returnType ?? 'number'],
     wasm,
-    memory,
     internal: true,
     index: currentFuncIndex++
   };
@@ -796,7 +844,8 @@ const TYPES = {
   bigint: 0xffffffffffff7,
 
   // these are not "typeof" types but tracked internally
-  _array: 0xffffffffffff8
+  _array: 0xfffffffffff0f,
+  _regexp: 0xfffffffffff1f
 };
 
 const TYPE_NAMES = {
@@ -831,6 +880,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];
   }
 
@@ -864,6 +915,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;
@@ -907,6 +963,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);
@@ -946,7 +1007,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++;
@@ -967,6 +1029,8 @@ const countLeftover = wasm => {
           } else count--;
           if (func) count += func.returns.length;
         } else count--;
+
+    // console.log(count, decompile([ inst ]).slice(0, -1));
   }
 
   return count;
@@ -1050,7 +1114,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('_');
@@ -1065,6 +1129,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;
@@ -1073,11 +1156,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) {
@@ -1085,7 +1193,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);
 
@@ -1109,24 +1217,34 @@ const generateCall = (scope, decl, _global, _name) => {
     // 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, (length, itemType) => {
+      return makeArray(scope, {
+        rawElements: new Array(length)
+      }, _global, _name, true, itemType);
+    });
+
     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 ]
     ];
   }
@@ -1183,11 +1301,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 ]);
@@ -1198,7 +1315,7 @@ 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 (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);
@@ -1307,8 +1424,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');
@@ -1329,13 +1444,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
 
     // 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`)
@@ -1349,8 +1511,10 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
-  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),
@@ -1359,8 +1523,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 ]
   ];
@@ -1390,10 +1572,11 @@ const generateUnary = (scope, decl) => {
       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
       ];
@@ -1474,7 +1657,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');
@@ -1567,18 +1750,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;
 };
@@ -1669,19 +1940,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}`);
@@ -1698,7 +1969,7 @@ const itemTypeToValtype = {
   i16: 'i32'
 };
 
-const storeOps = {
+const StoreOps = {
   i32: Opcodes.i32_store,
   i64: Opcodes.i64_store,
   f64: Opcodes.f64_store,
@@ -1707,13 +1978,28 @@ const storeOps = {
   i16: Opcodes.i32_store16
 };
 
+let data = [];
+
+const compileBytes = (val, itemType, signed = true) => {
+  switch (itemType) {
+    case 'i8': return enforceOneByte(unsignedLEB128(val));
+    case 'i16': return enforceTwoBytes(unsignedLEB128(val));
+    case 'i32': return enforceFourBytes(signedLEB128(val));
+    case 'i64': return enforceEightBytes(signedLEB128(val));
+    case 'f64': return enforceEightBytes(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);
@@ -1721,8 +2007,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),
@@ -1730,8 +2037,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;
@@ -1746,8 +2052,6 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   // local value as pointer
   out.push(...number(pointer));
 
-  scope.memory = true;
-
   return [ out, pointer ];
 };
 
@@ -1766,8 +2070,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 [
@@ -1787,8 +2089,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) {
@@ -1898,7 +2198,7 @@ const generateFunc = (scope, decl) => {
     locals: {},
     localInd: 0,
     returns: [ valtypeBinary ],
-    memory: false,
+    returnType: null,
     throws: false,
     name
   };
@@ -1924,7 +2224,6 @@ const generateFunc = (scope, decl) => {
     returns: innerScope.returns,
     returnType: innerScope.returnType,
     locals: innerScope.locals,
-    memory: innerScope.memory,
     throws: innerScope.throws,
     index: currentFuncIndex++
   };
@@ -1939,6 +2238,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
@@ -1949,9 +2250,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 ]
@@ -2062,10 +2361,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;
@@ -2101,6 +2400,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
   }
 };
 
@@ -2115,6 +2426,7 @@ export default program => {
   typeStates = {};
   arrays = new Map();
   pages = new Map();
+  data = [];
   currentFuncIndex = importedFuncs.length;
 
   globalThis.valtype = 'f64';
@@ -2191,5 +2503,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 };
 };