porffor 0.14.0-86ac87fa4 → 0.14.0-af9ac5ad4

package/compiler/codegen.js

@@ -203,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))
         ],
       };
 
@@ -403,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
     ];
@@ -422,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 ]
   ];
 };
@@ -456,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 ],
@@ -516,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 ],
@@ -598,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 ],
@@ -693,6 +681,25 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
     ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
 
     // ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
+    // [ Opcodes.i32_eqz ],
+
+    // ...(intIn ? [
+    //   ...number(0, Valtype.i32),
+    //   [ Opcodes.i32_gt_s ]
+    // ] : [
+    //   ...number(0),
+    //   [ Opcodes.f64_gt ]
+    // ]),
+
+    // ...(intOut ? [] : [ Opcodes.i32_from ]),
+
+    // ...(intIn ? [] : [ Opcodes.i32_to ]),
+    // [ Opcodes.if, intOut ? Valtype.i32 : valtypeBinary ],
+    // ...number(1, intOut ? Valtype.i32 : valtypeBinary),
+    // [ Opcodes.else ],
+    // ...number(0, intOut ? Valtype.i32 : valtypeBinary),
+    // [ Opcodes.end ],
+
     ...(!intOut || (intIn && intOut) ? [] : [ Opcodes.i32_to_u ]),
 
     /* Opcodes.eqz,
@@ -1056,7 +1063,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;
 
@@ -1104,6 +1111,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;
 
@@ -1197,9 +1210,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 = (() => {
@@ -1260,7 +1274,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_')) {
@@ -1355,22 +1379,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);
 
@@ -1473,7 +1502,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;
@@ -1564,16 +1593,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) {
@@ -1625,8 +1648,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)
       ];
     }
 
@@ -1698,9 +1720,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;
         }
@@ -1719,7 +1739,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);
@@ -1733,9 +1753,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 ]
         ];
       }
@@ -1904,6 +1922,7 @@ 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 ]);
@@ -1988,8 +2007,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;
@@ -2120,6 +2142,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;
 
@@ -2136,7 +2169,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;
@@ -2349,18 +2382,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`)
@@ -2614,21 +2650,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 +2807,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 +2824,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 ],
 
@@ -3109,7 +3143,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();
@@ -3172,7 +3206,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),
@@ -3180,14 +3214,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]) ]
+      ])
     );
   }
 
@@ -3197,6 +3237,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;
 
@@ -3225,7 +3324,7 @@ 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') => {
@@ -3233,17 +3332,20 @@ const generateObject = (scope, decl, global = false, name = '$undeclared') => {
 
   return [
     ...number(1),
-
-    ...number(TYPES.object, Valtype.i32),
-    ...setLastType(scope)
+    ...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') {
@@ -3253,9 +3355,9 @@ 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);
     }
   }
 
@@ -3265,7 +3367,7 @@ 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']) {
@@ -3275,24 +3377,88 @@ 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);
 
@@ -3307,24 +3473,7 @@ 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)
     ],
 
@@ -3355,9 +3504,7 @@ 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
@@ -3383,9 +3530,7 @@ 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)
@@ -3410,7 +3555,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;
       }