porffor 0.14.0-4e46400a9 → 0.14.0-549a04f84

package/compiler/codegen.js

@@ -140,6 +140,9 @@ 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);
 
@@ -200,19 +203,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))
         ],
       };
 
@@ -351,9 +346,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 ]
   ];
 };
@@ -402,13 +395,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
     ];
@@ -421,13 +412,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 ]
   ];
 };
@@ -455,11 +444,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 ],
@@ -515,11 +504,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 ],
@@ -597,11 +586,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 ],
@@ -1055,7 +1044,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 = [], callsSelf = false }) => {
   const existing = funcs.find(x => x.name === name);
   if (existing) return existing;
 
@@ -1103,6 +1092,12 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     index: currentFuncIndex++
   };
 
+  if (callsSelf) for (const inst of wasm) {
+    if (inst[0] === Opcodes.call && inst[1] === -1) {
+      inst[1] = func.index;
+    }
+  }
+
   funcs.push(func);
   funcIndex[name] = func.index;
 
@@ -1196,9 +1191,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 = (() => {
@@ -1259,7 +1255,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_')) {
@@ -1354,22 +1360,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);
 
@@ -1451,6 +1462,10 @@ const countLeftover = wasm => {
             } else count--;
             if (func) count += 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));
@@ -1468,7 +1483,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;
@@ -1559,16 +1574,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) {
@@ -1620,8 +1629,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)
       ];
     }
 
@@ -1693,9 +1701,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;
         }
@@ -1714,7 +1720,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);
@@ -1728,9 +1734,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 ]
         ];
       }
@@ -1833,22 +1837,44 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
   if (idx === undefined) {
     if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) {
-      if (!Prefs.indirectCalls) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
-
       const [ local, global ] = lookupName(scope, name);
-      funcs.table = true;
+      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
-      return typeSwitch(scope, getNodeType(decl.callee), {
+
+      funcs.table = true;
+
+      let args = decl.arguments;
+      let argWasm = [];
+
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        argWasm = argWasm.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);
+        }
+
+        argWasm = argWasm.concat(getNodeType(scope, arg));
+      }
+
+      return typeSwitch(scope, getNodeType(scope, decl.callee), {
         [TYPES.function]: [
+          ...argWasm,
           [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
-          [ Opcodes.call_indirect ]
+          Opcodes.i32_to_u,
+          [ Opcodes.call_indirect, args.length, 0 ],
+          ...setLastType(scope)
         ],
         default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
       });
     }
+
     return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
   }
 
@@ -1877,6 +1903,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'))
@@ -1925,6 +1958,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);
@@ -1950,8 +1988,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;
@@ -2082,6 +2123,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;
 
@@ -2098,7 +2150,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;
@@ -2311,18 +2363,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`)
@@ -2499,6 +2554,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'),
 
@@ -2575,21 +2631,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 ]);
@@ -2737,12 +2788,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 ],
 
@@ -2751,9 +2805,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 ],
 
@@ -3070,7 +3124,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();
@@ -3133,7 +3187,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),
@@ -3141,14 +3195,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]) ]
+      ])
     );
   }
 
@@ -3158,6 +3218,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;
 
@@ -3186,14 +3305,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];
+};
+
+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)
+  ];
 };
 
-export const generateMember = (scope, decl, _global, _name) => {
+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') {
@@ -3203,9 +3336,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);
     }
   }
 
@@ -3215,7 +3348,7 @@ export const generateMember = (scope, decl, _global, _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);
+      return withType(scope, number(typedParams ? func.params.length / 2 : func.params.length), TYPES.number);
     }
 
     if (builtinFuncs[name + '$constructor']) {
@@ -3225,24 +3358,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);
 
@@ -3257,24 +3454,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)
     ],
 
@@ -3305,9 +3485,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
@@ -3333,9 +3511,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)
@@ -3360,7 +3536,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;
       }
@@ -3628,8 +3804,10 @@ const internalConstrs = {
           }),
 
           // print space
-          ...number(32),
-          [ Opcodes.call, importedFuncs.printChar ]
+          ...(i !== decl.arguments.length - 1 ? [
+            ...number(32),
+            [ Opcodes.call, importedFuncs.printChar ]
+          ] : [])
         );
       }
 
@@ -3639,6 +3817,8 @@ const internalConstrs = {
         [ Opcodes.call, importedFuncs.printChar ]
       );
 
+      out.push(...number(UNDEFINED));
+
       return out;
     },
     type: TYPES.undefined,