porffor 0.2.0-fdf0fc5 → 0.14.0-0ad2c8a7c

package/compiler/codegen.js

@@ -1,14 +1,14 @@
-import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from "./wasmSpec.js";
-import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } 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, enforceOneByte, enforceTwoBytes, enforceFourBytes, enforceEightBytes } from "./embedding.js";
-import { log } from "./log.js";
-import parse from "./parse.js";
-import * as Rhemyn from "../rhemyn/compile.js";
-import Prefs from './prefs.js';
+import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from './wasmSpec.js';
+import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from './encoding.js';
+import { operatorOpcode } from './expression.js';
+import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
+import { PrototypeFuncs } from './prototype.js';
+import { number } from './embedding.js';
 import { TYPES, TYPE_NAMES } from './types.js';
+import * as Rhemyn from '../rhemyn/compile.js';
+import parse from './parse.js';
+import { log } from './log.js';
+import Prefs from './prefs.js';
 
 let globals = {};
 let globalInd = 0;
@@ -19,24 +19,6 @@ let funcIndex = {};
 let currentFuncIndex = importedFuncs.length;
 let builtinFuncs = {}, builtinVars = {}, prototypeFuncs = {};
 
-const debug = str => {
-  const code = [];
-
-  const logChar = n => {
-    code.push(...number(n));
-
-    code.push([ Opcodes.call, 0 ]);
-  };
-
-  for (let i = 0; i < str.length; i++) {
-    logChar(str.charCodeAt(i));
-  }
-
-  logChar(10); // new line
-
-  return code;
-};
-
 class TodoError extends Error {
   constructor(message) {
     super(message);
@@ -58,11 +40,11 @@ const todo = (scope, msg, expectsValue = undefined) => {
   }
 };
 
-const isFuncType = type => type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
-const hasFuncWithName = name => {
-  const func = funcs.find(x => x.name === name);
-  return !!(func || builtinFuncs[name] || importedFuncs[name] || internalConstrs[name]);
-};
+const isFuncType = type =>
+  type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
+const hasFuncWithName = name =>
+  funcIndex[name] != null || builtinFuncs[name] != null || importedFuncs[name] != null || internalConstrs[name] != null;
+
 const generate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
   switch (decl.type) {
     case 'BinaryExpression':
@@ -76,10 +58,11 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
     case 'ArrowFunctionExpression':
     case 'FunctionDeclaration':
+    case 'FunctionExpression':
       const func = generateFunc(scope, decl);
 
       if (decl.type.endsWith('Expression')) {
-        return number(func.index);
+        return number(func.index - importedFuncs.length);
       }
 
       return [];
@@ -157,24 +140,24 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'ArrayExpression':
       return generateArray(scope, decl, global, name);
 
+    case 'ObjectExpression':
+      return generateObject(scope, decl, global, name);
+
     case 'MemberExpression':
       return generateMember(scope, decl, global, name);
 
     case 'ExportNamedDeclaration':
-      // hack to flag new func for export
-      const funcsBefore = funcs.length;
+      const funcsBefore = funcs.map(x => x.name);
       generate(scope, decl.declaration);
 
-      if (funcsBefore !== funcs.length) {
-        // new func added
-        const newFunc = funcs[funcs.length - 1];
-        newFunc.export = true;
-      }
-
-      // if (funcsBefore === funcs.length) throw new Error('no new func added in export');
+      // set new funcs as exported
+      if (funcsBefore.length !== funcs.length) {
+        const newFuncs = funcs.filter(x => !funcsBefore.includes(x.name)).filter(x => !x.internal);
 
-      // const newFunc = funcs[funcs.length - 1];
-      // newFunc.export = true;
+        for (const x of newFuncs) {
+          x.export = true;
+        }
+      }
 
       return [];
 
@@ -210,7 +193,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
             if (!Array.isArray(inst)) inst = [ inst ];
             const immediates = asm.slice(1).map(x => {
               const int = parseInt(x);
-              if (Number.isNaN(int)) return scope.locals[x]?.idx;
+              if (Number.isNaN(int)) return scope.locals[x]?.idx ?? globals[x].idx;
               return int;
             });
 
@@ -222,19 +205,11 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
         __Porffor_bs: str => [
           ...makeString(scope, str, global, name, true),
-
-          ...(name ? setType(scope, name, TYPES.bytestring) : [
-            ...number(TYPES.bytestring, Valtype.i32),
-            ...setLastType(scope)
-          ])
+          ...(name ? setType(scope, name, TYPES.bytestring) : setLastType(scope, TYPES.bytestring))
         ],
         __Porffor_s: str => [
           ...makeString(scope, str, global, name, false),
-
-          ...(name ? setType(scope, name, TYPES.string) : [
-            ...number(TYPES.string, Valtype.i32),
-            ...setLastType(scope)
-          ])
+          ...(name ? setType(scope, name, TYPES.string) : setLastType(scope, TYPES.string))
         ],
       };
 
@@ -336,10 +311,10 @@ const generateIdent = (scope, decl) => {
 
     if (local?.idx === undefined) {
       // no local var with name
-      if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name]);
-      if (Object.hasOwn(funcIndex, name)) return number(funcIndex[name]);
-
       if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name].idx ] ];
+
+      if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name] - importedFuncs.length);
+      if (Object.hasOwn(funcIndex, name)) return number(funcIndex[name] - importedFuncs.length);
     }
 
     if (local?.idx === undefined && rawName.startsWith('__')) {
@@ -373,9 +348,7 @@ const generateReturn = (scope, decl) => {
 
   return [
     ...generate(scope, decl.argument),
-    ...(scope.returnType != null ? [] : [
-      ...getNodeType(scope, decl.argument)
-    ]),
+    ...(scope.returnType != null ? [] : getNodeType(scope, decl.argument)),
     [ Opcodes.return ]
   ];
 };
@@ -390,7 +363,7 @@ const localTmp = (scope, name, type = valtypeBinary) => {
 };
 
 const isIntOp = op => op && ((op[0] >= 0x45 && op[0] <= 0x4f) || (op[0] >= 0x67 && op[0] <= 0x78) || op[0] === 0x41);
-const isFloatToIntOp = op => op && (op[0] >= 0xb7 && op[0] <= 0xba);
+const isIntToFloatOp = op => op && (op[0] >= 0xb7 && op[0] <= 0xba);
 
 const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   const checks = {
@@ -407,10 +380,10 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
 
   // 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 = isFloatToIntOp(left[left.length - 1]);
-  const rightIsInt = isFloatToIntOp(right[right.length - 1]);
+  const leftWasInt = isIntToFloatOp(left[left.length - 1]);
+  const rightWasInt = isIntToFloatOp(right[right.length - 1]);
 
-  const canInt = leftIsInt && rightIsInt;
+  const canInt = leftWasInt && rightWasInt;
 
   if (canInt) {
     // remove int -> float conversions from left and right
@@ -424,13 +397,11 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
       [ Opcodes.if, Valtype.i32 ],
       ...right,
       // note type
-      ...rightType,
-      ...setLastType(scope),
+      ...setLastType(scope, rightType),
       [ Opcodes.else ],
       [ Opcodes.local_get, localTmp(scope, 'logictmpi', Valtype.i32) ],
       // note type
-      ...leftType,
-      ...setLastType(scope),
+      ...setLastType(scope, leftType),
       [ Opcodes.end ],
       Opcodes.i32_from
     ];
@@ -443,13 +414,11 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
     [ Opcodes.if, valtypeBinary ],
     ...right,
     // note type
-    ...rightType,
-    ...setLastType(scope),
+    ...setLastType(scope, rightType),
     [ Opcodes.else ],
     [ Opcodes.local_get, localTmp(scope, 'logictmp') ],
     // note type
-    ...leftType,
-    ...setLastType(scope),
+    ...setLastType(scope, leftType),
     [ Opcodes.end ]
   ];
 };
@@ -477,11 +446,11 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
       ...number(0, Valtype.i32), // base 0 for store later
 
       ...number(pointer, Valtype.i32),
-      [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+      [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
       [ Opcodes.local_tee, leftLength ],
 
       [ Opcodes.local_get, rightPointer ],
-      [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+      [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
       [ Opcodes.local_tee, rightLength ],
 
       [ Opcodes.i32_add ],
@@ -537,11 +506,11 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
     ...number(0, Valtype.i32), // base 0 for store later
 
     [ Opcodes.local_get, leftPointer ],
-    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
     [ Opcodes.local_tee, leftLength ],
 
     [ Opcodes.local_get, rightPointer ],
-    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
     [ Opcodes.local_tee, rightLength ],
 
     [ Opcodes.i32_add ],
@@ -619,11 +588,11 @@ const compareStrings = (scope, left, right, bytestrings = false) => {
 
     // get lengths
     [ Opcodes.local_get, leftPointer ],
-    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
     [ Opcodes.local_tee, leftLength ],
 
     [ Opcodes.local_get, rightPointer ],
-    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.i32_load, 0, ...unsignedLEB128(0) ],
 
     // fast path: check leftLength != rightLength
     [ Opcodes.i32_ne ],
@@ -679,9 +648,9 @@ const compareStrings = (scope, left, right, bytestrings = false) => {
     [ Opcodes.i32_add ],
     [ Opcodes.local_tee, index ],
 
-    // if index != index end (length * sizeof valtype), loop
+    // if index < index end (length * sizeof valtype), loop
     [ Opcodes.local_get, indexEnd ],
-    [ Opcodes.i32_ne ],
+    [ Opcodes.i32_lt_s ],
     [ Opcodes.br_if, 0 ],
     [ Opcodes.end ],
 
@@ -699,38 +668,50 @@ const compareStrings = (scope, left, right, bytestrings = false) => {
   ];
 };
 
-const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
-  if (isFloatToIntOp(wasm[wasm.length - 1])) return [
+const truthy = (scope, wasm, type, intIn = false, intOut = false, forceTruthyMode = undefined) => {
+  if (isIntToFloatOp(wasm[wasm.length - 1])) return [
     ...wasm,
     ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
   ];
   // if (isIntOp(wasm[wasm.length - 1])) return [ ...wasm ];
 
+  // todo/perf: use knownType and custom bytecode here instead of typeSwitch
+
   const useTmp = knownType(scope, type) == null;
   const tmp = useTmp && localTmp(scope, `#logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
 
-  const def = [
-    // if value != 0
-    ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
+  const def = (truthyMode => {
+    if (truthyMode === 'full') return [
+      // if value != 0 or NaN
+      ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
+      ...(intIn ? [ ] : [ Opcodes.i32_to ]),
 
-    // ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
-    ...(!intOut || (intIn && intOut) ? [] : [ Opcodes.i32_to_u ]),
+      [ Opcodes.i32_eqz ],
+      [ Opcodes.i32_eqz ],
 
-    /* Opcodes.eqz,
-    [ Opcodes.i32_eqz ],
-    Opcodes.i32_from */
-  ];
+      ...(intOut ? [] : [ Opcodes.i32_from ]),
+    ];
+
+    if (truthyMode === 'no_negative') return [
+      // if value != 0 or NaN, non-binary output. negative numbers not truthy :/
+      ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
+      ...(intIn ? [] : [ Opcodes.i32_to ]),
+      ...(intOut ? [] : [ Opcodes.i32_from ])
+    ];
+
+    if (truthyMode === 'no_nan_negative') return [
+      // simpler and faster but makes NaN truthy and negative numbers not truthy,
+      // plus non-binary output
+      ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
+      ...(!intOut || (intIn && intOut) ? [] : [ Opcodes.i32_to_u ])
+    ];
+  })(forceTruthyMode ?? Prefs.truthy ?? 'full');
 
   return [
     ...wasm,
     ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
-      // [TYPES.number]: def,
-      [TYPES.array]: [
-        // arrays are always truthy
-        ...number(1, intOut ? Valtype.i32 : valtypeBinary)
-      ],
       [TYPES.string]: [
         ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
@@ -766,10 +747,6 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
     ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
-      [TYPES.array]: [
-        // arrays are always truthy
-        ...number(0, intOut ? Valtype.i32 : valtypeBinary)
-      ],
       [TYPES.string]: [
         ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
@@ -858,31 +835,6 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 
   // if strict (in)equal check types match
   if (strictOp) {
-    // startOut.push(
-    //   ...leftType,
-    //   ...rightType,
-    //   [ Opcodes.i32_eq ]
-    // );
-
-    // endOut.push(
-    //   [ Opcodes.i32_and ]
-    // );
-
-    // startOut.push(
-    //   [ Opcodes.block, Valtype.i32 ],
-    //   ...leftType,
-    //   ...rightType,
-    //   [ Opcodes.i32_ne ],
-    //   [ Opcodes.if, Blocktype.void ],
-    //   ...number(op === '===' ? 0 : 1, Valtype.i32),
-    //   [ Opcodes.br, 1 ],
-    //   [ Opcodes.end ]
-    // );
-
-    // endOut.push(
-    //   [ Opcodes.end ]
-    // );
-
     endOut.push(
       ...leftType,
       ...rightType,
@@ -1038,7 +990,7 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
       // if both are true
       [ Opcodes.i32_and ],
       [ Opcodes.if, Blocktype.void ],
-      ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ]),
+      ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ], false),
       ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : []),
       [ Opcodes.br, 1 ],
       [ Opcodes.end ],
@@ -1087,14 +1039,14 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
   return out;
 };
 
-const asmFuncToAsm = (func, { name = '#unknown_asm_func', params = [], locals = [], returns = [], localInd = 0 }) => {
-  return func({ name, params, locals, returns, localInd }, {
-    TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage,
-    builtin: name => {
-      let idx = funcIndex[name] ?? importedFuncs[name];
-      if (idx === undefined && builtinFuncs[name]) {
-        includeBuiltin(null, name);
-        idx = funcIndex[name];
+const asmFuncToAsm = (func, scope) => {
+  return func(scope, {
+    TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage, internalThrow,
+    builtin: n => {
+      let idx = funcIndex[n] ?? importedFuncs[n];
+      if (idx == null && builtinFuncs[n]) {
+        includeBuiltin(null, n);
+        idx = funcIndex[n];
       }
 
       return idx;
@@ -1102,7 +1054,7 @@ const asmFuncToAsm = (func, { name = '#unknown_asm_func', params = [], locals =
   });
 };
 
-const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [], data: _data = [] }) => {
+const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [], data: _data = [], table = false }) => {
   const existing = funcs.find(x => x.name === name);
   if (existing) return existing;
 
@@ -1120,7 +1072,22 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     data.push(copy);
   }
 
-  if (typeof wasm === 'function') wasm = asmFuncToAsm(wasm, { name, params, locals, returns, localInd: allLocals.length });
+  const func = {
+    name,
+    params,
+    locals,
+    localInd: allLocals.length,
+    returns,
+    returnType: returnType ?? TYPES.number,
+    internal: true,
+    index: currentFuncIndex++,
+    table
+  };
+
+  funcs.push(func);
+  funcIndex[name] = func.index;
+
+  if (typeof wasm === 'function') wasm = asmFuncToAsm(wasm, func);
 
   let baseGlobalIdx, i = 0;
   for (const type of globalTypes) {
@@ -1139,19 +1106,14 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     }
   }
 
-  const func = {
-    name,
-    params,
-    locals,
-    returns,
-    returnType: returnType ?? TYPES.number,
-    wasm,
-    internal: true,
-    index: currentFuncIndex++
-  };
+  if (table) for (const inst of wasm) {
+    if (inst[0] === Opcodes.i32_load16_u && inst.at(-1) === 'read_argc') {
+      inst.splice(2, 99);
+      inst.push(...unsignedLEB128(allocPage({}, 'func argc lut') * pageSize));
+    }
+  }
 
-  funcs.push(func);
-  funcIndex[name] = func.index;
+  func.wasm = wasm;
 
   return func;
 };
@@ -1243,12 +1205,13 @@ const getLastType = scope => {
   return [ [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ] ];
 };
 
-const setLastType = scope => {
-  return [ [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ] ];
-};
+const setLastType = (scope, type = []) => [
+  ...(typeof type === 'number' ? number(type, Valtype.i32) : type),
+  [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+];
 
 const getNodeType = (scope, node) => {
-  const inner = () => {
+  const ret = (() => {
     if (node.type === 'Literal') {
       if (node.regex) return TYPES.regexp;
 
@@ -1291,7 +1254,6 @@ const getNodeType = (scope, node) => {
       const func = funcs.find(x => x.name === name);
 
       if (func) {
-        // console.log(scope, func, func.returnType);
         if (func.returnType) return func.returnType;
       }
 
@@ -1307,7 +1269,17 @@ const getNodeType = (scope, node) => {
 
         const func = spl[spl.length - 1];
         const protoFuncs = Object.keys(prototypeFuncs).filter(x => x != TYPES.bytestring && prototypeFuncs[x][func] != null);
-        if (protoFuncs.length === 1) return protoFuncs[0].returnType ?? TYPES.number;
+        if (protoFuncs.length === 1) {
+          if (protoFuncs[0].returnType) return protoFuncs[0].returnType;
+        }
+
+        if (protoFuncs.length > 0) {
+          if (scope.locals['#last_type']) return getLastType(scope);
+
+          // presume
+          // todo: warn here?
+          return TYPES.number;
+        }
       }
 
       if (name.startsWith('__Porffor_wasm_')) {
@@ -1402,22 +1374,27 @@ const getNodeType = (scope, node) => {
     }
 
     if (node.type === 'MemberExpression') {
-      // hack: if something.name, string type
-      if (node.property.name === 'name') {
-        if (hasFuncWithName(node.object.name)) {
-          return TYPES.bytestring;
-        } else {
-          return TYPES.undefined;
-        }
+      const name = node.property.name;
+
+      if (name === 'length') {
+        if (hasFuncWithName(node.object.name)) return TYPES.number;
+        if (Prefs.fastLength) return TYPES.number;
       }
 
-      // hack: if something.length, number type
-      if (node.property.name === 'length') return TYPES.number;
 
-      // ts hack
-      if (scope.locals[node.object.name]?.metadata?.type === TYPES.string) return TYPES.string;
-      if (scope.locals[node.object.name]?.metadata?.type === TYPES.bytestring) return TYPES.bytestring;
-      if (scope.locals[node.object.name]?.metadata?.type === TYPES.array) return TYPES.number;
+      const objectKnownType = knownType(scope, getNodeType(scope, node.object));
+      if (objectKnownType != null) {
+        if (name === 'length') {
+          if ([ TYPES.string, TYPES.bytestring, TYPES.array ].includes(objectKnownType)) return TYPES.number;
+            else return TYPES.undefined;
+        }
+
+        if (node.computed) {
+          if (objectKnownType === TYPES.string) return TYPES.string;
+          if (objectKnownType === TYPES.bytestring) return TYPES.bytestring;
+          if (objectKnownType === TYPES.array) return TYPES.number;
+        }
+      }
 
       if (scope.locals['#last_type']) return getLastType(scope);
 
@@ -1435,10 +1412,8 @@ const getNodeType = (scope, node) => {
     // presume
     // todo: warn here?
     return TYPES.number;
-  };
+  })();
 
-  const ret = inner();
-  // console.trace(node, ret);
   if (typeof ret === 'number') return number(ret, Valtype.i32);
   return ret;
 };
@@ -1490,17 +1465,16 @@ const countLeftover = wasm => {
         else if (inst[0] === Opcodes.return) count = 0;
         else if (inst[0] === Opcodes.call) {
           let func = funcs.find(x => x.index === inst[1]);
-          if (inst[1] === -1) {
-            // todo: count for calling self
-          } else if (!func && inst[1] < importedFuncs.length) {
-            count -= importedFuncs[inst[1]].params;
-            count += importedFuncs[inst[1]].returns;
+          if (inst[1] < importedFuncs.length) {
+            func = importedFuncs[inst[1]];
+            count = count - func.params + func.returns;
           } else {
-            if (func) {
-              count -= func.params.length;
-            } else count--;
-            if (func) count += func.returns.length;
+            count = count - func.params.length + func.returns.length;
           }
+        } else if (inst[0] === Opcodes.call_indirect) {
+          count--; // funcidx
+          count -= inst[1] * 2; // params * 2 (typed)
+          count += 2; // fixed return (value, type)
         } else count--;
 
     // console.log(count, decompile([ inst ]).slice(0, -1));
@@ -1518,7 +1492,7 @@ const disposeLeftover = wasm => {
 const generateExp = (scope, decl) => {
   const expression = decl.expression;
 
-  const out = generate(scope, expression, undefined, undefined, true);
+  const out = generate(scope, expression, undefined, undefined, Prefs.optUnused);
   disposeLeftover(out);
 
   return out;
@@ -1577,15 +1551,6 @@ const RTArrayUtil = {
 };
 
 const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
-  /* const callee = decl.callee;
-  const args = decl.arguments;
-
-  return [
-    ...generate(args),
-    ...generate(callee),
-    Opcodes.call_indirect,
-  ]; */
-
   let name = mapName(decl.callee.name);
   if (isFuncType(decl.callee.type)) { // iife
     const func = generateFunc(scope, decl.callee);
@@ -1618,16 +1583,10 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       out.splice(out.length - 1, 1);
 
       const finalStatement = parsed.body[parsed.body.length - 1];
-      out.push(
-        ...getNodeType(scope, finalStatement),
-        ...setLastType(scope)
-      );
+      out.push(...setLastType(scope, getNodeType(scope, finalStatement)));
     } else if (countLeftover(out) === 0) {
       out.push(...number(UNDEFINED));
-      out.push(
-        ...number(TYPES.undefined, Valtype.i32),
-        ...setLastType(scope)
-      );
+      out.push(...setLastType(scope, TYPES.undefined));
     }
 
     // if (lastInst && lastInst[0] === Opcodes.drop) {
@@ -1663,6 +1622,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
       if (!funcIndex[rhemynName]) {
         const func = Rhemyn[funcName](regex, currentFuncIndex++, rhemynName);
+        func.internal = true;
 
         funcIndex[func.name] = func.index;
         funcs.push(func);
@@ -1679,8 +1639,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         [ Opcodes.call, idx ],
         Opcodes.i32_from_u,
 
-        ...number(TYPES.boolean, Valtype.i32),
-        ...setLastType(scope)
+        ...setLastType(scope, TYPES.boolean)
       ];
     }
 
@@ -1752,15 +1711,11 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         if (protoFunc.noArgRetLength && decl.arguments.length === 0) {
           protoBC[x] = [
             ...RTArrayUtil.getLength(getPointer),
-
-            ...number(TYPES.number, Valtype.i32),
-            ...setLastType(scope)
+            ...setLastType(scope, TYPES.number)
           ];
           continue;
         }
 
-        // const protoLocal = protoFunc.local ? localTmp(scope, `__${TYPE_NAMES[x]}_${protoName}_tmp`, protoFunc.local) : -1;
-        // const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${TYPE_NAMES[x]}_${protoName}_tmp2`, protoFunc.local2) : -1;
         const protoLocal = protoFunc.local ? localTmp(scope, `__${protoName}_tmp`, protoFunc.local) : -1;
         const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${protoName}_tmp2`, protoFunc.local2) : -1;
 
@@ -1775,7 +1730,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           getI32: () => RTArrayUtil.getLengthI32(getPointer),
           set: value => RTArrayUtil.setLength(getPointer, value),
           setI32: value => RTArrayUtil.setLengthI32(getPointer, value)
-        }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, protoLocal2, (length, itemType) => {
+        }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, protoLocal2, (length, itemType) => {
           return makeArray(scope, {
             rawElements: new Array(length)
           }, _global, _name, true, itemType);
@@ -1789,9 +1744,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         protoBC[x] = [
           [ Opcodes.block, unusedValue && optUnused ? Blocktype.void : valtypeBinary ],
           ...protoOut,
-
-          ...number(protoFunc.returnType ?? TYPES.number, Valtype.i32),
-          ...setLastType(scope),
+          ...(unusedValue && optUnused ? [] : (protoFunc.returnType != null ? setLastType(scope, protoFunc.returnType) : setLastType(scope))),
           [ Opcodes.end ]
         ];
       }
@@ -1837,31 +1790,10 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
     includeBuiltin(scope, name);
     idx = funcIndex[name];
-
-    // infer arguments types from builtins params
-    // const func = funcs.find(x => x.name === name);
-    // for (let i = 0; i < decl.arguments.length; i++) {
-    //   const arg = decl.arguments[i];
-    //   if (!arg.name) continue;
-
-    //   const local = scope.locals[arg.name];
-    //   if (!local) continue;
-
-    //   local.type = func.params[i];
-    //   if (local.type === Valtype.v128) {
-    //     // specify vec subtype inferred from last vec type in function name
-    //     local.vecType = name.split('_').reverse().find(x => x.includes('x'));
-    //   }
-    // }
   }
 
   if (idx === undefined && internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
 
-  if (idx === undefined && name === scope.name) {
-    // hack: calling self, func generator will fix later
-    idx = -1;
-  }
-
   if (idx === undefined && name.startsWith('__Porffor_wasm_')) {
     const wasmOps = {
       // pointer, align, offset
@@ -1909,15 +1841,144 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   if (idx === undefined) {
-    if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+    if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) {
+      const [ local, global ] = lookupName(scope, name);
+      if (!Prefs.indirectCalls || local == null) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+
+      // todo: only works when function uses typedParams and typedReturns
+
+      const indirectMode = Prefs.indirectCallMode ?? 'vararg';
+      // options: vararg, strict
+      // - strict: simpler, smaller size usage, no func argc lut needed.
+      //   ONLY works when arg count of call == arg count of function being called
+      // - vararg: large size usage, cursed.
+      //   works when arg count of call != arg count of function being called*
+      //   * most of the time, some edgecases
+
+      funcs.table = true;
+      scope.table = true;
+
+      let args = decl.arguments;
+      let out = [];
+
+      let locals = [];
+
+      if (indirectMode === 'vararg') {
+        const minArgc = Prefs.indirectCallMinArgc ?? 3;
+
+        if (args.length < minArgc) {
+          args = args.concat(new Array(minArgc - args.length).fill(DEFAULT_VALUE));
+        }
+      }
+
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        out = out.concat(generate(scope, arg));
+
+        if (valtypeBinary !== Valtype.i32 && (
+          (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
+          (importedFuncs[name] && name.startsWith('profile'))
+        )) {
+          out.push(Opcodes.i32_to);
+        }
+
+        out = out.concat(getNodeType(scope, arg));
+
+        if (indirectMode === 'vararg') {
+          const typeLocal = localTmp(scope, `#indirect_arg${i}_type`, Valtype.i32);
+          const valLocal = localTmp(scope, `#indirect_arg${i}_val`);
+
+          locals.push([valLocal, typeLocal]);
+
+          out.push(
+            [ Opcodes.local_set, typeLocal ],
+            [ Opcodes.local_set, valLocal ]
+          );
+        }
+      }
+
+      if (indirectMode === 'strict') {
+        return typeSwitch(scope, getNodeType(scope, decl.callee), {
+          [TYPES.function]: [
+            ...argWasm,
+            [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+            Opcodes.i32_to_u,
+            [ Opcodes.call_indirect, args.length, 0 ],
+            ...setLastType(scope)
+          ],
+          default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
+        });
+      }
+
+      // hi, I will now explain how vararg mode works:
+      // wasm's indirect_call instruction requires you know the func type at compile-time
+      // since we have varargs (variable argument count), we do not know it.
+      // we could just store args in memory and not use wasm func args,
+      // but that is slow (probably) and breaks js exports.
+      // instead, we generate every* possibility of argc and use different indirect_call
+      // ops for each one, with type depending on argc for that branch.
+      // then we load the argc for the wanted function from a memory lut,
+      // and call the branch with the matching argc we require.
+      // sorry, yes it is very cursed (and size inefficient), but indirect calls
+      // are kind of rare anyway (mostly callbacks) so I am not concerned atm.
+      // *for argc 0-3, in future (todo:) the max number should be
+      // dynamically changed to the max argc of any func in the js file.
+
+      const funcLocal = localTmp(scope, `#indirect_func`, Valtype.i32);
+
+      const gen = argc => {
+        const out = [];
+        for (let i = 0; i < argc; i++) {
+          out.push(
+            [ Opcodes.local_get, locals[i][0] ],
+            [ Opcodes.local_get, locals[i][1] ]
+          );
+        }
+
+        out.push(
+          [ Opcodes.local_get, funcLocal ],
+          [ Opcodes.call_indirect, argc, 0 ],
+          ...setLastType(scope)
+        )
+
+        return out;
+      };
+
+      const tableBc = {};
+      for (let i = 0; i <= args.length; i++) {
+        tableBc[i] = gen(i);
+      }
+
+      // todo/perf: check if we should use br_table here or just generate our own big if..elses
+
+      return typeSwitch(scope, getNodeType(scope, decl.callee), {
+        [TYPES.function]: [
+          ...out,
+
+          [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+          Opcodes.i32_to_u,
+          [ Opcodes.local_set, funcLocal ],
+
+          ...brTable([
+            // get argc of func we are calling
+            [ Opcodes.local_get, funcLocal ],
+            ...number(ValtypeSize.i16, Valtype.i32),
+            [ Opcodes.i32_mul ],
+
+            [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func argc lut') * pageSize), 'read_argc' ]
+          ], tableBc, valtypeBinary)
+        ],
+        default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
+      });
+    }
+
     return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
   }
 
-  const func = funcs.find(x => x.index === idx);
-
-  const userFunc = (funcIndex[name] && !importedFuncs[name] && !builtinFuncs[name] && !internalConstrs[name]) || idx === -1;
+  const func = funcs[idx - importedFuncs.length]; // idx === scope.index ? scope : funcs.find(x => x.index === idx);
+  const userFunc = func && !func.internal;
   const typedParams = userFunc || builtinFuncs[name]?.typedParams;
-  const typedReturns = (func ? func.returnType == null : userFunc) || builtinFuncs[name]?.typedReturns;
+  const typedReturns = (func && func.returnType == null) || builtinFuncs[name]?.typedReturns;
   const paramCount = func && (typedParams ? func.params.length / 2 : func.params.length);
 
   let args = decl.arguments;
@@ -1938,11 +1999,17 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     const arg = args[i];
     out = out.concat(generate(scope, arg));
 
-    if (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
-      out.push(Opcodes.i32_to);
+    // todo: this should be used instead of the too many args thing above (by removing that)
+    if (i >= paramCount) {
+      // over param count of func, drop arg
+      out.push([ Opcodes.drop ]);
+      continue;
     }
 
-    if (importedFuncs[name] && name.startsWith('profile')) {
+    if (valtypeBinary !== Valtype.i32 && (
+      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
+      (importedFuncs[name] && name.startsWith('profile'))
+    )) {
       out.push(Opcodes.i32_to);
     }
 
@@ -1987,6 +2054,11 @@ const generateNew = (scope, decl, _global, _name) => {
     }, _global, _name);
   }
 
+  if (
+    (builtinFuncs[name] && !builtinFuncs[name].constr) ||
+    (internalConstrs[name] && builtinFuncs[name].notConstr)
+  ) return internalThrow(scope, 'TypeError', `${name} is not a constructor`);
+
   if (!builtinFuncs[name]) return todo(scope, `new statement is not supported yet`); // return todo(scope, `new statement is not supported yet (new ${unhackName(name)})`);
 
   return generateCall(scope, decl, _global, _name);
@@ -2012,8 +2084,11 @@ const knownType = (scope, type) => {
     const idx = type[0][1];
 
     // type idx = var idx + 1
-    const v = Object.values(scope.locals).find(x => x.idx === idx - 1);
-    if (v.metadata?.type != null) return v.metadata.type;
+    const name = Object.values(scope.locals).find(x => x.idx === idx)?.name;
+    if (name) {
+      const local = scope.locals[name];
+      if (local.metadata?.type != null) return v.metadata.type;
+    }
   }
 
   return null;
@@ -2048,16 +2123,17 @@ const brTable = (input, bc, returns) => {
   }
 
   for (let i = 0; i < count; i++) {
-    if (i === 0) out.push([ Opcodes.block, returns, 'br table start' ]);
+    // if (i === 0) out.push([ Opcodes.block, returns, 'br table start' ]);
+    if (i === 0) out.push([ Opcodes.block, returns ]);
       else out.push([ Opcodes.block, Blocktype.void ]);
   }
 
-  const nums = keys.filter(x => +x);
+  const nums = keys.filter(x => +x >= 0);
   const offset = Math.min(...nums);
   const max = Math.max(...nums);
 
   const table = [];
-  let br = 1;
+  let br = 0;
 
   for (let i = offset; i <= max; i++) {
     // if branch for this num, go to that block
@@ -2097,10 +2173,9 @@ const brTable = (input, bc, returns) => {
     br--;
   }
 
-  return [
-    ...out,
-    [ Opcodes.end, 'br table end' ]
-  ];
+  out.push([ Opcodes.end ]);
+
+  return out;
 };
 
 const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
@@ -2144,6 +2219,17 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
   return out;
 };
 
+const typeIsOneOf = (type, types, valtype = Valtype.i32) => {
+  const out = [];
+
+  for (let i = 0; i < types.length; i++) {
+    out.push(...type, ...number(types[i], valtype), valtype === Valtype.f64 ? [ Opcodes.f64_eq ] : [ Opcodes.i32_eq ]);
+    if (i !== 0) out.push([ Opcodes.i32_or ]);
+  }
+
+  return out;
+};
+
 const allocVar = (scope, name, global = false, type = true) => {
   const target = global ? globals : scope.locals;
 
@@ -2160,7 +2246,7 @@ const allocVar = (scope, name, global = false, type = true) => {
 
   if (type) {
     let typeIdx = global ? globalInd++ : scope.localInd++;
-    target[name + '#type'] = { idx: typeIdx, type: Valtype.i32 };
+    target[name + '#type'] = { idx: typeIdx, type: Valtype.i32, name };
   }
 
   return idx;
@@ -2178,7 +2264,6 @@ const addVarMetadata = (scope, name, global = false, metadata = {}) => {
 const typeAnnoToPorfType = x => {
   if (!x) return null;
   if (TYPES[x.toLowerCase()] != null) return TYPES[x.toLowerCase()];
-  if (TYPES['_' + x.toLowerCase()] != null) return TYPES['_' + x.toLowerCase()];
 
   switch (x) {
     case 'i32':
@@ -2219,9 +2304,8 @@ const generateVar = (scope, decl) => {
 
   const topLevel = scope.name === 'main';
 
-  // global variable if in top scope (main) and var ..., or if wanted
-  const global = topLevel || decl._bare; // decl.kind === 'var';
-  const target = global ? globals : scope.locals;
+  // global variable if in top scope (main) or if internally wanted
+  const global = topLevel || decl._bare;
 
   for (const x of decl.declarations) {
     const name = mapName(x.id.name);
@@ -2235,7 +2319,6 @@ const generateVar = (scope, decl) => {
       continue;
     }
 
-    // console.log(name);
     if (topLevel && builtinVars[name]) {
       // cannot redeclare
       if (decl.kind !== 'var') return internalThrow(scope, 'SyntaxError', `Identifier '${unhackName(name)}' has already been declared`);
@@ -2255,6 +2338,22 @@ const generateVar = (scope, decl) => {
     }
 
     if (x.init) {
+      // if (isFuncType(x.init.type)) {
+      //   // let a = function () { ... }
+      //   x.init.id = { name };
+
+      //   const func = generateFunc(scope, x.init);
+
+      //   out.push(
+      //     ...number(func.index - importedFuncs.length),
+      //     [ global ? Opcodes.global_set : Opcodes.local_set, idx ],
+
+      //     ...setType(scope, name, TYPES.function)
+      //   );
+
+      //   continue;
+      // }
+
       const generated = generate(scope, x.init, global, name);
       if (scope.arrays?.get(name) != null) {
         // hack to set local as pointer before
@@ -2266,6 +2365,7 @@ const generateVar = (scope, decl) => {
         out = out.concat(generated);
         out.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
       }
+
       out.push(...setType(scope, name, getNodeType(scope, x.init)));
     }
 
@@ -2279,6 +2379,7 @@ const generateVar = (scope, decl) => {
 // todo: optimize this func for valueUnused
 const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   const { type, name } = decl.left;
+  const [ local, isGlobal ] = lookupName(scope, name);
 
   if (type === 'ObjectPattern') {
     // hack: ignore object parts of `var a = {} = 2`
@@ -2288,8 +2389,18 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   if (isFuncType(decl.right.type)) {
     // hack for a = function () { ... }
     decl.right.id = { name };
-    generateFunc(scope, decl.right);
-    return [];
+
+    const func = generateFunc(scope, decl.right);
+
+    return [
+      ...number(func.index - importedFuncs.length),
+      ...(local != null ? [
+        [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+
+        ...setType(scope, name, TYPES.function)
+      ] : [])
+    ];
   }
 
   const op = decl.operator.slice(0, -1) || '=';
@@ -2348,18 +2459,21 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
           Opcodes.i32_to_u,
 
           // turn into byte offset by * valtypeSize (4 for i32, 8 for i64/f64)
-          ...number(ValtypeSize[valtype], Valtype.i32),
+          ...number(ValtypeSize[valtype] + 1, Valtype.i32),
           [ Opcodes.i32_mul ],
           ...(aotPointer ? [] : [ [ Opcodes.i32_add ] ]),
           ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
           ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
             [ Opcodes.local_get, pointerTmp ],
-            [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
-          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.load, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+          ], generate(scope, decl.right), [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
+          ], getNodeType(scope, decl.right), false, name, true)),
           [ Opcodes.local_tee, newValueTmp ],
 
-          [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
+          [ Opcodes.store, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ]
         ],
 
         default: internalThrow(scope, 'TypeError', `Cannot assign member with non-array`)
@@ -2388,8 +2502,6 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
   if (!name) return todo(scope, 'destructuring is not supported yet', true);
 
-  const [ local, isGlobal ] = lookupName(scope, name);
-
   if (local === undefined) {
     // todo: this should be a sloppy mode only thing
 
@@ -2469,6 +2581,11 @@ const generateUnary = (scope, decl) => {
       ];
 
     case '!':
+      const arg = decl.argument;
+      if (arg.type === "UnaryExpression" && arg.operator === "!") {
+        // !!x -> is x truthy
+        return truthy(scope, generate(scope, arg.argument), getNodeType(scope, arg.argument), false, false);
+      }
       // !=
       return falsy(scope, generate(scope, decl.argument), getNodeType(scope, decl.argument), false, false);
 
@@ -2538,6 +2655,7 @@ const generateUnary = (scope, decl) => {
         [TYPES.string]: makeString(scope, 'string', false, '#typeof_result'),
         [TYPES.undefined]: makeString(scope, 'undefined', false, '#typeof_result'),
         [TYPES.function]: makeString(scope, 'function', false, '#typeof_result'),
+        [TYPES.symbol]: makeString(scope, 'symbol', false, '#typeof_result'),
 
         [TYPES.bytestring]: makeString(scope, 'string', false, '#typeof_result'),
 
@@ -2614,21 +2732,16 @@ const generateConditional = (scope, decl) => {
   out.push([ Opcodes.if, valtypeBinary ]);
   depth.push('if');
 
-  out.push(...generate(scope, decl.consequent));
-
-  // note type
   out.push(
-    ...getNodeType(scope, decl.consequent),
-    ...setLastType(scope)
+    ...generate(scope, decl.consequent),
+    ...setLastType(scope, getNodeType(scope, decl.consequent))
   );
 
   out.push([ Opcodes.else ]);
-  out.push(...generate(scope, decl.alternate));
 
-  // note type
   out.push(
-    ...getNodeType(scope, decl.alternate),
-    ...setLastType(scope)
+    ...generate(scope, decl.alternate),
+    ...setLastType(scope, getNodeType(scope, decl.alternate))
   );
 
   out.push([ Opcodes.end ]);
@@ -2776,12 +2889,15 @@ const generateForOf = (scope, decl) => {
   // todo: optimize away counter and use end pointer
   out.push(...typeSwitch(scope, getNodeType(scope, decl.right), {
     [TYPES.array]: [
-      ...setType(scope, leftName, TYPES.number),
-
       [ Opcodes.loop, Blocktype.void ],
 
       [ Opcodes.local_get, pointer ],
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      ...setType(scope, leftName, [
+        [ Opcodes.local_get, pointer ],
+        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
+      ]),
 
       [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
 
@@ -2790,9 +2906,9 @@ const generateForOf = (scope, decl) => {
       ...generate(scope, decl.body),
       [ Opcodes.end ],
 
-      // increment iter pointer by valtype size
+      // increment iter pointer by valtype size + 1
       [ Opcodes.local_get, pointer ],
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_add ],
       [ Opcodes.local_set, pointer ],
 
@@ -2908,6 +3024,44 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
+    [TYPES.set]: [
+      [ Opcodes.loop, Blocktype.void ],
+
+      [ Opcodes.local_get, pointer ],
+      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      ...setType(scope, leftName, [
+        [ Opcodes.local_get, pointer ],
+        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
+      ]),
+
+      [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+
+      [ Opcodes.block, Blocktype.void ],
+      [ Opcodes.block, Blocktype.void ],
+      ...generate(scope, decl.body),
+      [ Opcodes.end ],
+
+      // increment iter pointer by valtype size + 1
+      [ Opcodes.local_get, pointer ],
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_set, pointer ],
+
+      // increment counter by 1
+      [ Opcodes.local_get, counter ],
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_tee, counter ],
+
+      // loop if counter != length
+      [ Opcodes.local_get, length ],
+      [ Opcodes.i32_ne ],
+      [ Opcodes.br_if, 1 ],
+
+      [ Opcodes.end ],
+      [ Opcodes.end ]
+    ],
     default: internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`)
   }, Blocktype.void));
 
@@ -3009,14 +3163,18 @@ const generateThrow = (scope, decl) => {
 };
 
 const generateTry = (scope, decl) => {
-  if (decl.finalizer) return todo(scope, 'try finally not implemented yet');
+  // todo: handle control-flow pre-exit for finally
+  // "Immediately before a control-flow statement (return, throw, break, continue) is executed in the try block or catch block."
 
   const out = [];
 
+  const finalizer = decl.finalizer ? generate(scope, decl.finalizer) : [];
+
   out.push([ Opcodes.try, Blocktype.void ]);
   depth.push('try');
 
   out.push(...generate(scope, decl.block));
+  out.push(...finalizer);
 
   if (decl.handler) {
     depth.pop();
@@ -3024,6 +3182,7 @@ const generateTry = (scope, decl) => {
 
     out.push([ Opcodes.catch_all ]);
     out.push(...generate(scope, decl.handler.body));
+    out.push(...finalizer);
   }
 
   out.push([ Opcodes.end ]);
@@ -3036,13 +3195,6 @@ const generateEmpty = (scope, decl) => {
   return [];
 };
 
-const generateAssignPat = (scope, decl) => {
-  // TODO
-  // if identifier declared, use that
-  // else, use default (right)
-  return todo(scope, 'assignment pattern (optional arg)');
-};
-
 let pages = new Map();
 const allocPage = (scope, reason, type) => {
   if (pages.has(reason)) return pages.get(reason).ind;
@@ -3116,7 +3268,7 @@ const getAllocType = itemType => {
   }
 };
 
-const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false, itemType = valtype) => {
+const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false, itemType = valtype, typed = false) => {
   const out = [];
 
   scope.arrays ??= new Map();
@@ -3128,8 +3280,13 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     // 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;
 
-    if (Prefs.scopedPageNames) scope.arrays.set(name, allocPage(scope, `${getAllocType(itemType)}: ${scope.name}/${uniqueName}`, itemType) * pageSize);
-      else scope.arrays.set(name, allocPage(scope, `${getAllocType(itemType)}: ${uniqueName}`, itemType) * pageSize);
+    let page;
+    if (Prefs.scopedPageNames) page = allocPage(scope, `${getAllocType(itemType)}: ${scope.name}/${uniqueName}`, itemType);
+      else page = allocPage(scope, `${getAllocType(itemType)}: ${uniqueName}`, itemType);
+
+    // hack: use 1 for page 0 pointer for fast truthiness
+    const ptr = page === 0 ? 1 : (page * pageSize);
+    scope.arrays.set(name, ptr);
   }
 
   const pointer = scope.arrays.get(name);
@@ -3179,7 +3336,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
 
   const pointerWasm = pointerTmp != null ? [ [ Opcodes.local_get, pointerTmp ] ] : number(pointer, Valtype.i32);
 
-  // store length as 0th array
+  // store length
   out.push(
     ...pointerWasm,
     ...number(length, Valtype.i32),
@@ -3187,14 +3344,20 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   );
 
   const storeOp = StoreOps[itemType];
-
+  const sizePerEl = ValtypeSize[itemType] + (typed ? 1 : 0);
   if (!initEmpty) for (let i = 0; i < length; i++) {
     if (elements[i] == null) continue;
 
+    const offset = ValtypeSize.i32 + i * sizePerEl;
     out.push(
       ...pointerWasm,
       ...(useRawElements ? number(elements[i], Valtype[valtype]) : generate(scope, elements[i])),
-      [ storeOp, (Math.log2(ValtypeSize[itemType]) || 1) - 1, ...unsignedLEB128(ValtypeSize.i32 + i * ValtypeSize[itemType]) ]
+      [ storeOp, 0, ...unsignedLEB128(offset) ],
+      ...(!typed ? [] : [ // typed presumes !useRawElements
+        ...pointerWasm,
+        ...getNodeType(scope, elements[i]),
+        [ Opcodes.i32_store8, 0, ...unsignedLEB128(offset + ValtypeSize[itemType]) ]
+      ])
     );
   }
 
@@ -3204,6 +3367,65 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   return [ out, pointer ];
 };
 
+const storeArray = (scope, array, index, element, aotPointer = null) => {
+  if (!Array.isArray(element)) element = generate(scope, element);
+  if (typeof index === 'number') index = number(index);
+
+  const offset = localTmp(scope, '#storeArray_offset', Valtype.i32);
+
+  return [
+    // calculate offset
+    ...index,
+    Opcodes.i32_to_u,
+    ...number(ValtypeSize[valtype] + 1, Valtype.i32),
+    [ Opcodes.i32_mul ],
+    ...(aotPointer ? [] : [
+      ...array,
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_add ],
+    ]),
+    [ Opcodes.local_set, offset ],
+
+    // store value
+    [ Opcodes.local_get, offset ],
+    ...generate(scope, element),
+    [ Opcodes.store, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
+
+    // store type
+    [ Opcodes.local_get, offset ],
+    ...getNodeType(scope, element),
+    [ Opcodes.i32_store8, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
+  ];
+};
+
+const loadArray = (scope, array, index, aotPointer = null) => {
+  if (typeof index === 'number') index = number(index);
+
+  const offset = localTmp(scope, '#loadArray_offset', Valtype.i32);
+
+  return [
+    // calculate offset
+    ...index,
+    Opcodes.i32_to_u,
+    ...number(ValtypeSize[valtype] + 1, Valtype.i32),
+    [ Opcodes.i32_mul ],
+    ...(aotPointer ? [] : [
+      ...array,
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_add ],
+    ]),
+    [ Opcodes.local_set, offset ],
+
+    // load value
+    [ Opcodes.local_get, offset ],
+    [ Opcodes.load, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
+
+    // load type
+    [ Opcodes.local_get, offset ],
+    [ Opcodes.i32_load8_u, 0, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32 + ValtypeSize[valtype]) ]
+  ];
+};
+
 const byteStringable = str => {
   if (!Prefs.bytestring) return false;
 
@@ -3232,14 +3454,28 @@ const makeString = (scope, str, global = false, name = '$undeclared', forceBytes
 };
 
 const generateArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false) => {
-  return makeArray(scope, decl, global, name, initEmpty, valtype)[0];
+  return makeArray(scope, decl, global, name, initEmpty, valtype, true)[0];
 };
 
-export const generateMember = (scope, decl, _global, _name) => {
+const generateObject = (scope, decl, global = false, name = '$undeclared') => {
+  if (decl.properties.length > 0) return todo(scope, 'objects are not supported yet', true);
+
+  return [
+    ...number(1),
+    ...setLastType(scope, TYPES.object)
+  ];
+};
+
+const withType = (scope, wasm, type) => [
+  ...wasm,
+  ...setLastType(scope, type)
+];
+
+const generateMember = (scope, decl, _global, _name) => {
   const name = decl.object.name;
   const pointer = scope.arrays?.get(name);
 
-  const aotPointer = Prefs.aotPointerOpt && pointer != null;
+  const aotPointer = Prefs.aotPointerOpt && pointer;
 
   // hack: .name
   if (decl.property.name === 'name') {
@@ -3249,9 +3485,9 @@ export const generateMember = (scope, decl, _global, _name) => {
       // eg: __String_prototype_toLowerCase -> toLowerCase
       if (nameProp.startsWith('__')) nameProp = nameProp.split('_').pop();
 
-      return makeString(scope, nameProp, _global, _name, true);
+      return withType(scope, makeString(scope, nameProp, _global, _name, true), TYPES.bytestring);
     } else {
-      return generate(scope, DEFAULT_VALUE);
+      return withType(scope, number(0), TYPES.undefined);
     }
   }
 
@@ -3259,9 +3495,8 @@ export const generateMember = (scope, decl, _global, _name) => {
   if (decl.property.name === 'length') {
     const func = funcs.find(x => x.name === name);
     if (func) {
-      const userFunc = funcIndex[name] && !importedFuncs[name] && !builtinFuncs[name] && !internalConstrs[name];
-      const typedParams = userFunc || builtinFuncs[name]?.typedParams;
-      return number(typedParams ? func.params.length / 2 : func.params.length);
+      const typedParams = !func.internal || builtinFuncs[name]?.typedParams;
+      return withType(scope, number(typedParams ? func.params.length / 2 : func.params.length), TYPES.number);
     }
 
     if (builtinFuncs[name + '$constructor']) {
@@ -3271,24 +3506,88 @@ export const generateMember = (scope, decl, _global, _name) => {
       const constructorFunc = builtinFuncs[name + '$constructor'];
       const constructorParams = constructorFunc.typedParams ? (constructorFunc.params.length / 2) : constructorFunc.params.length;
 
-      return number(Math.max(regularParams, constructorParams));
+      return withType(scope, number(Math.max(regularParams, constructorParams)), TYPES.number);
+    }
+
+    if (builtinFuncs[name]) return withType(scope, number(builtinFuncs[name].typedParams ? (builtinFuncs[name].params.length / 2) : builtinFuncs[name].params.length), TYPES.number);
+    if (importedFuncs[name]) return withType(scope, number(importedFuncs[name].params), TYPES.number);
+    if (internalConstrs[name]) return withType(scope, number(internalConstrs[name].length ?? 0), TYPES.number);
+
+    if (Prefs.fastLength) {
+      // presume valid length object
+      return [
+        ...(aotPointer ? number(0, Valtype.i32) : [
+          ...generate(scope, decl.object),
+          Opcodes.i32_to_u
+        ]),
+
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
+        Opcodes.i32_from_u
+      ];
     }
 
-    if (builtinFuncs[name]) return number(builtinFuncs[name].typedParams ? (builtinFuncs[name].params.length / 2) : builtinFuncs[name].params.length);
-    if (importedFuncs[name]) return number(importedFuncs[name].params);
-    if (internalConstrs[name]) return number(internalConstrs[name].length ?? 0);
+    const type = getNodeType(scope, decl.object);
+    const known = knownType(scope, type);
+    if (known != null) {
+      if ([ TYPES.string, TYPES.bytestring, TYPES.array ].includes(known)) return [
+        ...(aotPointer ? number(0, Valtype.i32) : [
+          ...generate(scope, decl.object),
+          Opcodes.i32_to_u
+        ]),
+
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
+        Opcodes.i32_from_u
+      ];
+
+      return number(0);
+    }
 
     return [
-      ...(aotPointer ? number(0, Valtype.i32) : [
-        ...generate(scope, decl.object),
-        Opcodes.i32_to_u
-      ]),
+      ...typeIsOneOf(getNodeType(scope, decl.object), [ TYPES.string, TYPES.bytestring, TYPES.array ]),
+      [ Opcodes.if, valtypeBinary ],
+        ...(aotPointer ? number(0, Valtype.i32) : [
+          ...generate(scope, decl.object),
+          Opcodes.i32_to_u
+        ]),
 
-      [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128((aotPointer ? pointer : 0)) ],
-      Opcodes.i32_from_u
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(aotPointer ? pointer : 0) ],
+        Opcodes.i32_from_u,
+
+        ...setLastType(scope, TYPES.number),
+      [ Opcodes.else ],
+        ...number(0),
+        ...setLastType(scope, TYPES.undefined),
+      [ Opcodes.end ]
     ];
   }
 
+  // todo: generate this array procedurally during builtinFuncs creation
+  if (['size', 'description'].includes(decl.property.name)) {
+    const bc = {};
+    const cands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + decl.property.name + '$get'));
+
+    if (cands.length > 0) {
+      for (const x of cands) {
+        const type = TYPES[x.split('_prototype_')[0].slice(2).toLowerCase()];
+        if (type == null) continue;
+
+        bc[type] = generateCall(scope, {
+          callee: {
+            type: 'Identifier',
+            name: x
+          },
+          arguments: [ decl.object ],
+          _protoInternalCall: true
+        });
+      }
+    }
+
+    return typeSwitch(scope, getNodeType(scope, decl.object), {
+      ...bc,
+      default: withType(scope, number(0), TYPES.undefined)
+    }, valtypeBinary);
+  }
+
   const object = generate(scope, decl.object);
   const property = generate(scope, decl.property);
 
@@ -3303,24 +3602,7 @@ export const generateMember = (scope, decl, _global, _name) => {
 
   return typeSwitch(scope, getNodeType(scope, decl.object), {
     [TYPES.array]: [
-      // get index as valtype
-      ...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 ? [] : [
-        ...object,
-        Opcodes.i32_to_u,
-        [ Opcodes.i32_add ]
-      ]),
-
-      // read from memory
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
-
-      ...number(TYPES.number, Valtype.i32),
+      ...loadArray(scope, object, property, aotPointer),
       ...setLastType(scope)
     ],
 
@@ -3351,9 +3633,7 @@ export const generateMember = (scope, decl, _global, _name) => {
 
       // return new string (page)
       ...number(newPointer),
-
-      ...number(TYPES.string, Valtype.i32),
-      ...setLastType(scope)
+      ...setLastType(scope, TYPES.string)
     ],
     [TYPES.bytestring]: [
       // setup new/out array
@@ -3379,9 +3659,7 @@ export const generateMember = (scope, decl, _global, _name) => {
 
       // return new string (page)
       ...number(newPointer),
-
-      ...number(TYPES.bytestring, Valtype.i32),
-      ...setLastType(scope)
+      ...setLastType(scope, TYPES.bytestring)
     ],
 
     default: internalThrow(scope, 'TypeError', 'Member expression is not supported for non-string non-array yet', true)
@@ -3406,7 +3684,7 @@ const objectHack = node => {
       if (!objectName) objectName = objectHack(node.object)?.name?.slice?.(2);
 
       // if .name or .length, give up (hack within a hack!)
-      if (['name', 'length'].includes(node.property.name)) {
+      if (['name', 'length', 'size', 'description'].includes(node.property.name)) {
         node.object = objectHack(node.object);
         return;
       }
@@ -3443,30 +3721,39 @@ const generateFunc = (scope, decl) => {
   const name = decl.id ? decl.id.name : `anonymous_${randId()}`;
   const params = decl.params ?? [];
 
-  // const innerScope = { ...scope };
   // TODO: share scope/locals between !!!
-  const innerScope = {
+  const func = {
     locals: {},
     localInd: 0,
     // value, type
     returns: [ valtypeBinary, Valtype.i32 ],
     throws: false,
-    name
+    name,
+    index: currentFuncIndex++
   };
 
   if (typedInput && decl.returnType) {
-    innerScope.returnType = extractTypeAnnotation(decl.returnType).type;
-    innerScope.returns = [ valtypeBinary ];
+    const { type } = extractTypeAnnotation(decl.returnType);
+    // if (type != null && !Prefs.indirectCalls) {
+    if (type != null) {
+      func.returnType = type;
+      func.returns = [ valtypeBinary ];
+    }
   }
 
   for (let i = 0; i < params.length; i++) {
-    allocVar(innerScope, params[i].name, false);
+    const name = params[i].name;
+    // if (name == null) return todo('non-identifier args are not supported');
+
+    allocVar(func, name, false);
 
     if (typedInput && params[i].typeAnnotation) {
-      addVarMetadata(innerScope, params[i].name, false, extractTypeAnnotation(params[i]));
+      addVarMetadata(func, name, false, extractTypeAnnotation(params[i]));
     }
   }
 
+  func.params = Object.values(func.locals).map(x => x.type);
+
   let body = objectHack(decl.body);
   if (decl.type === 'ArrowFunctionExpression' && decl.expression) {
     // hack: () => 0 -> () => return 0
@@ -3476,37 +3763,23 @@ const generateFunc = (scope, decl) => {
     };
   }
 
-  const wasm = generate(innerScope, body);
-  const func = {
-    name,
-    params: Object.values(innerScope.locals).slice(0, params.length * 2).map(x => x.type),
-    index: currentFuncIndex++,
-    ...innerScope
-  };
   funcIndex[name] = func.index;
+  funcs.push(func);
 
-  if (name === 'main') func.gotLastType = true;
+  const wasm = generate(func, body);
+  func.wasm = wasm;
 
-  // quick hack fixes
-  for (const inst of wasm) {
-    if (inst[0] === Opcodes.call && inst[1] === -1) {
-      inst[1] = func.index;
-    }
-  }
+  if (name === 'main') func.gotLastType = true;
 
   // add end return if not found
   if (name !== 'main' && wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
     wasm.push(
       ...number(0),
-      ...number(TYPES.undefined, Valtype.i32),
+      ...(func.returnType != null ? [] : number(TYPES.undefined, Valtype.i32)),
       [ Opcodes.return ]
     );
   }
 
-  func.wasm = wasm;
-
-  funcs.push(func);
-
   return func;
 };
 
@@ -3610,7 +3883,7 @@ const internalConstrs = {
     generate: (scope, decl) => {
       // todo: boolean object when used as constructor
       const arg = decl.arguments[0] ?? DEFAULT_VALUE;
-      return truthy(scope, generate(scope, arg), getNodeType(scope, arg));
+      return truthy(scope, generate(scope, arg), getNodeType(scope, arg), false, false, 'full');
     },
     type: TYPES.boolean,
     length: 1
@@ -3671,8 +3944,10 @@ const internalConstrs = {
           }),
 
           // print space
-          ...number(32),
-          [ Opcodes.call, importedFuncs.printChar ]
+          ...(i !== decl.arguments.length - 1 ? [
+            ...number(32),
+            [ Opcodes.call, importedFuncs.printChar ]
+          ] : [])
         );
       }
 
@@ -3682,6 +3957,8 @@ const internalConstrs = {
         [ Opcodes.call, importedFuncs.printChar ]
       );
 
+      out.push(...number(UNDEFINED));
+
       return out;
     },
     type: TYPES.undefined,
@@ -3751,9 +4028,8 @@ export default program => {
 
   if (Prefs.astLog) console.log(JSON.stringify(program.body.body, null, 2));
 
-  generateFunc(scope, program);
+  const main = generateFunc(scope, program);
 
-  const main = funcs[funcs.length - 1];
   main.export = true;
   main.returns = [ valtypeBinary, Valtype.i32 ];
 
@@ -3780,7 +4056,7 @@ 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);
+  if (main.wasm.length === 0 && funcs.reduce((acc, x) => acc + (x.export ? 1 : 0), 0) > 1) funcs.splice(main.index - importedFuncs.length, 1);
 
   return { funcs, globals, tags, exceptions, pages, data };
 };