porffor 0.14.0-a24ac8cf2 → 0.14.0-b1e1c2265

package/compiler/codegen.js

@@ -40,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':
@@ -140,18 +140,23 @@ 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;
+      // set new funcs as exported
+      if (funcsBefore.length !== funcs.length) {
+        const newFuncs = funcs.filter(x => !funcsBefore.includes(x.name)).filter(x => !x.internal);
+
+        for (const x of newFuncs) {
+          x.export = true;
+        }
       }
 
       return [];
@@ -200,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))
         ],
       };
 
@@ -366,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 = {
@@ -383,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
@@ -400,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
     ];
@@ -419,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 ]
   ];
 };
@@ -453,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 ],
@@ -513,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 ],
@@ -595,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 ],
@@ -655,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 ],
 
@@ -675,8 +668,8 @@ 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 ] : [])
   ];
@@ -685,28 +678,38 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
   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 ]),
@@ -742,10 +745,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 ]),
@@ -989,7 +988,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 ],
@@ -1038,14 +1037,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 }, {
+const asmFuncToAsm = (func, scope) => {
+  return func(scope, {
     TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage, internalThrow,
-    builtin: name => {
-      let idx = funcIndex[name] ?? importedFuncs[name];
-      if (idx === undefined && builtinFuncs[name]) {
-        includeBuiltin(null, name);
-        idx = funcIndex[name];
+    builtin: n => {
+      let idx = funcIndex[n] ?? importedFuncs[n];
+      if (idx == null && builtinFuncs[n]) {
+        includeBuiltin(null, n);
+        idx = funcIndex[n];
       }
 
       return idx;
@@ -1053,7 +1052,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;
 
@@ -1071,7 +1070,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) {
@@ -1090,19 +1104,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;
 };
@@ -1194,9 +1203,10 @@ 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 ret = (() => {
@@ -1257,7 +1267,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_')) {
@@ -1352,22 +1372,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);
 
@@ -1438,16 +1463,11 @@ 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
@@ -1470,7 +1490,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;
@@ -1561,16 +1581,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) {
@@ -1606,6 +1620,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);
@@ -1622,8 +1637,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)
       ];
     }
 
@@ -1695,9 +1709,7 @@ 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;
         }
@@ -1716,7 +1728,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);
@@ -1730,9 +1742,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 ]
         ];
       }
@@ -1782,11 +1792,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
   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
@@ -1838,36 +1843,128 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       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:
-      //   1. arg count matches arg count of function
-      //   2. function uses typedParams and typedReturns
+      // 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 argWasm = [];
+      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];
-        argWasm = argWasm.concat(generate(scope, arg));
+        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'))
         )) {
-          argWasm.push(Opcodes.i32_to);
+          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] ]
+          );
         }
 
-        argWasm = argWasm.concat(getNodeType(scope, arg));
+        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]: [
-          ...argWasm,
+          ...out,
+
           [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
           Opcodes.i32_to_u,
-          [ Opcodes.call_indirect, args.length, 0 ],
-          ...setLastType(scope)
+          [ 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)
       });
@@ -1876,11 +1973,10 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     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;
@@ -1901,6 +1997,13 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     const arg = args[i];
     out = out.concat(generate(scope, arg));
 
+    // 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 (valtypeBinary !== Valtype.i32 && (
       (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
       (importedFuncs[name] && name.startsWith('profile'))
@@ -1949,6 +2052,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);
@@ -1974,8 +2082,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;
@@ -2010,16 +2121,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
@@ -2059,10 +2171,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) => {
@@ -2106,6 +2217,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;
 
@@ -2122,7 +2244,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;
@@ -2335,18 +2457,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`)
@@ -2454,6 +2579,7 @@ const generateUnary = (scope, decl) => {
       ];
 
     case '!':
+      // todo/perf: optimize !!
       // !=
       return falsy(scope, generate(scope, decl.argument), getNodeType(scope, decl.argument), false, false);
 
@@ -2523,6 +2649,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'),
 
@@ -2599,21 +2726,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 ]);
@@ -2761,12 +2883,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 ],
 
@@ -2775,9 +2900,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 ],
 
@@ -2994,14 +3119,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();
@@ -3009,6 +3138,7 @@ const generateTry = (scope, decl) => {
 
     out.push([ Opcodes.catch_all ]);
     out.push(...generate(scope, decl.handler.body));
+    out.push(...finalizer);
   }
 
   out.push([ Opcodes.end ]);
@@ -3094,7 +3224,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();
@@ -3106,8 +3236,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);
@@ -3157,7 +3292,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),
@@ -3165,14 +3300,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]) ]
+      ])
     );
   }
 
@@ -3182,6 +3323,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;
 
@@ -3210,14 +3410,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') {
@@ -3227,9 +3441,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);
     }
   }
 
@@ -3237,9 +3451,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']) {
@@ -3249,24 +3462,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 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);
+    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
+      ];
+    }
+
+    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);
 
@@ -3281,24 +3558,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)
     ],
 
@@ -3329,9 +3589,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
@@ -3357,9 +3615,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)
@@ -3384,7 +3640,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;
       }
@@ -3421,33 +3677,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) {
     const { type } = extractTypeAnnotation(decl.returnType);
-    if (type != null && !Prefs.indirectCalls) {
-      innerScope.returnType = type;
-      innerScope.returns = [ valtypeBinary ];
+    // 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
@@ -3457,37 +3719,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),
-      ...(innerScope.returnType != null ? [] : number(TYPES.undefined, Valtype.i32)),
+      ...(func.returnType != null ? [] : number(TYPES.undefined, Valtype.i32)),
       [ Opcodes.return ]
     );
   }
 
-  func.wasm = wasm;
-
-  funcs.push(func);
-
   return func;
 };
 
@@ -3591,7 +3839,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
@@ -3736,9 +3984,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 ];
 
@@ -3765,7 +4012,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 };
 };