porffor 0.19.8 → 0.19.10

package/compiler/codegen.js

@@ -39,7 +39,7 @@ const todo = (scope, msg, expectsValue = undefined) => {
 const isFuncType = type =>
   type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
 const hasFuncWithName = name =>
-  funcIndex[name] != null || builtinFuncs[name] != null || importedFuncs[name] != null || internalConstrs[name] != null;
+  Object.hasOwn(funcIndex, name) != null || Object.hasOwn(builtinFuncs, name) != null || Object.hasOwn(importedFuncs, name) != null || Object.hasOwn(internalConstrs, name) != null;
 
 const generate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
   switch (decl.type) {
@@ -75,6 +75,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'SequenceExpression':
       return generateSequence(scope, decl);
 
+    case 'ChainExpression':
+      return generateChain(scope, decl);
+
     case 'CallExpression':
       return generateCall(scope, decl, global, name, valueUnused);
 
@@ -260,11 +263,8 @@ const mapName = x => {
 const lookupName = (scope, _name) => {
   const name = mapName(_name);
 
-  let local = scope.locals[name];
-  if (local) return [ local, false ];
-
-  let global = globals[name];
-  if (global) return [ global, true ];
+  if (Object.hasOwn(scope.locals, name)) return [ scope.locals[name], false ];
+  if (Object.hasOwn(globals, name)) return [ globals[name], true ];
 
   return [ undefined, undefined ];
 };
@@ -297,7 +297,7 @@ const generateIdent = (scope, decl) => {
       if (builtinVars[name].floatOnly && valtype[0] === 'i') throw new Error(`Cannot use ${unhackName(name)} with integer valtype`);
 
       let wasm = builtinVars[name];
-      if (typeof wasm === 'function') wasm = asmFuncToAsm(wasm, { name });
+      if (typeof wasm === 'function') wasm = asmFuncToAsm({ name }, wasm);
       return wasm.slice();
     }
 
@@ -1119,7 +1119,7 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
   return out;
 };
 
-const asmFuncToAsm = (func, scope) => {
+const asmFuncToAsm = (scope, func) => {
   return func(scope, {
     TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage, internalThrow,
     builtin: n => {
@@ -1131,6 +1131,39 @@ const asmFuncToAsm = (func, scope) => {
 
       if (idx == null) throw new Error(`builtin('${n}') failed to find a func (inside ${scope.name})`);
       return idx;
+    },
+    glbl: (opcode, name, type) => {
+      if (!globals[name]) {
+        const idx = globals['#ind']++;
+        globals[name] = { idx, type };
+
+        const tmpIdx = globals['#ind']++;
+        globals[name + '#glbl_inited'] = { idx: tmpIdx, type: Valtype.i32 };
+
+        if (scope.globalInits[name]) return [
+          [ Opcodes.global_get, tmpIdx ],
+          [ Opcodes.i32_eqz ],
+          [ Opcodes.if, Blocktype.void ],
+          ...asmFuncToAsm(scope, scope.globalInits[name]),
+          ...number(1, Valtype.i32),
+          [ Opcodes.global_set, tmpIdx ],
+          [ Opcodes.end ],
+
+          [ opcode, globals[name].idx ]
+        ];
+      }
+
+      return [
+        [ opcode, globals[name].idx ]
+      ];
+    },
+    loc: (name, type) => {
+      if (!scope.locals[name]) {
+        const idx = scope.localInd++;
+        scope.locals[name] = { idx, type };
+      }
+
+      return scope.locals[name].idx;
     }
   });
 };
@@ -1165,7 +1198,8 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     internal: true,
     index: currentFuncIndex++,
     table,
-    constr
+    constr,
+    globalInits
   };
 
   funcs.push(func);
@@ -1173,7 +1207,7 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
 
   if (typeof wasm === 'function') {
     if (globalThis.precompile) wasm = [];
-      else wasm = asmFuncToAsm(wasm, func);
+      else wasm = asmFuncToAsm(func, wasm);
   }
 
   let baseGlobalIdx, i = 0;
@@ -1273,14 +1307,14 @@ const getType = (scope, _name) => {
   // if (scope.locals[name] && !scope.locals[name + '#type']) console.log(name);
 
   if (typedInput && scope.locals[name]?.metadata?.type != null) return number(scope.locals[name].metadata.type, Valtype.i32);
-  if (scope.locals[name]) return [ [ Opcodes.local_get, scope.locals[name + '#type'].idx ] ];
+  if (Object.hasOwn(scope.locals, name)) return [ [ Opcodes.local_get, scope.locals[name + '#type'].idx ] ];
 
   if (typedInput && globals[name]?.metadata?.type != null) return number(globals[name].metadata.type, Valtype.i32);
-  if (globals[name]) return [ [ Opcodes.global_get, globals[name + '#type'].idx ] ];
+  if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name + '#type'].idx ] ];
 
   let type = TYPES.undefined;
-  if (builtinVars[name]) type = builtinVars[name].type ?? TYPES.number;
-  if (builtinFuncs[name] !== undefined || importedFuncs[name] !== undefined || funcIndex[name] !== undefined || internalConstrs[name] !== undefined) type = TYPES.function;
+  if (Object.hasOwn(builtinVars, name)) type = builtinVars[name].type ?? TYPES.number;
+  if (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(importedFuncs, name) || Object.hasOwn(funcIndex, name) || Object.hasOwn(internalConstrs, name)) type = TYPES.function;
 
   if (isExistingProtoFunc(name)) type = TYPES.function;
 
@@ -1293,13 +1327,13 @@ const setType = (scope, _name, type) => {
   const out = typeof type === 'number' ? number(type, Valtype.i32) : type;
 
   if (typedInput && scope.locals[name]?.metadata?.type != null) return [];
-  if (scope.locals[name]) return [
+  if (Object.hasOwn(scope.locals, name)) return [
     ...out,
     [ Opcodes.local_set, scope.locals[name + '#type'].idx ]
   ];
 
   if (typedInput && globals[name]?.metadata?.type != null) return [];
-  if (globals[name]) return [
+  if (Object.hasOwn(globals, name)) return [
     ...out,
     [ Opcodes.global_set, globals[name + '#type'].idx ]
   ];
@@ -1342,7 +1376,7 @@ const getNodeType = (scope, node) => {
 
     if (node.type === 'CallExpression' || node.type === 'NewExpression') {
       const name = node.callee.name;
-      if (!name) {
+      if (name == null) {
         // iife
         if (scope.locals['#last_type']) return getLastType(scope);
 
@@ -1356,8 +1390,8 @@ const getNodeType = (scope, node) => {
         if (func.returnType != null) return func.returnType;
       }
 
-      if (builtinFuncs[name] && !builtinFuncs[name].typedReturns) return builtinFuncs[name].returnType ?? TYPES.number;
-      if (internalConstrs[name]) return internalConstrs[name].type;
+      if (Object.hasOwn(builtinFuncs, name) && !builtinFuncs[name].typedReturns) return builtinFuncs[name].returnType ?? TYPES.number;
+      if (Object.hasOwn(internalConstrs, name)) return internalConstrs[name].type;
 
       // check if this is a prototype function
       // if so and there is only one impl (eg charCodeAt)
@@ -1601,6 +1635,10 @@ const generateSequence = (scope, decl) => {
   return out;
 };
 
+const generateChain = (scope, decl) => {
+  return generate(scope, decl.expression);
+};
+
 const CTArrayUtil = {
   getLengthI32: pointer => [
     ...number(0, Valtype.i32),
@@ -1927,120 +1965,219 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   // TODO: only allows callee as identifier
   // if (!name) return todo(scope, `only identifier callees (got ${decl.callee.type})`);
 
-  let idx = funcIndex[name] ?? importedFuncs[name];
-  if (idx === undefined && builtinFuncs[name]) {
-    if (builtinFuncs[name].floatOnly && valtype !== 'f64') throw new Error(`Cannot use built-in ${unhackName(name)} with integer valtype`);
-    if (decl._new && !builtinFuncs[name].constr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
+  let idx;
+  if (Object.hasOwn(funcIndex, name)) idx = funcIndex[name];
+    else if (Object.hasOwn(importedFuncs, name)) idx = importedFuncs[name];
+    else if (Object.hasOwn(builtinFuncs, name)) {
+      if (builtinFuncs[name].floatOnly && valtype !== 'f64') throw new Error(`Cannot use built-in ${unhackName(name)} with integer valtype`);
+      if (decl._new && !builtinFuncs[name].constr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
 
-    includeBuiltin(scope, name);
-    idx = funcIndex[name];
-  }
+      includeBuiltin(scope, name);
+      idx = funcIndex[name];
+    } else if (Object.hasOwn(internalConstrs, name)) {
+      if (decl._new && internalConstrs[name].notConstr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
+      return internalConstrs[name].generate(scope, decl, _global, _name);
+    } else if (!decl._new && name && name.startsWith('__Porffor_wasm_')) {
+      const wasmOps = {
+        // pointer, align, offset
+        i32_load: { imms: 2, args: [ true ], returns: 1 },
+        // pointer, value, align, offset
+        i32_store: { imms: 2, args: [ true, true ], returns: 0 },
+        // pointer, align, offset
+        i32_load8_u: { imms: 2, args: [ true ], returns: 1 },
+        // pointer, value, align, offset
+        i32_store8: { imms: 2, args: [ true, true ], returns: 0 },
+        // pointer, align, offset
+        i32_load16_u: { imms: 2, args: [ true ], returns: 1 },
+        // pointer, value, align, offset
+        i32_store16: { imms: 2, args: [ true, true ], returns: 0 },
+
+        // pointer, align, offset
+        f64_load: { imms: 2, args: [ true ], returns: 0 }, // 0 due to not i32
+        // pointer, value, align, offset
+        f64_store: { imms: 2, args: [ true, false ], returns: 0 },
+
+        // value
+        i32_const: { imms: 1, args: [], returns: 0 },
+      };
 
-  if (idx === undefined && internalConstrs[name]) {
-    if (decl._new && internalConstrs[name].notConstr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
-    return internalConstrs[name].generate(scope, decl, _global, _name);
-  }
+      const opName = name.slice('__Porffor_wasm_'.length);
 
-  if (idx === undefined && !decl._new && name && name.startsWith('__Porffor_wasm_')) {
-    const wasmOps = {
-      // pointer, align, offset
-      i32_load: { imms: 2, args: [ true ], returns: 1 },
-      // pointer, value, align, offset
-      i32_store: { imms: 2, args: [ true, true ], returns: 0 },
-      // pointer, align, offset
-      i32_load8_u: { imms: 2, args: [ true ], returns: 1 },
-      // pointer, value, align, offset
-      i32_store8: { imms: 2, args: [ true, true ], returns: 0 },
-      // pointer, align, offset
-      i32_load16_u: { imms: 2, args: [ true ], returns: 1 },
-      // pointer, value, align, offset
-      i32_store16: { imms: 2, args: [ true, true ], returns: 0 },
-
-      // pointer, align, offset
-      f64_load: { imms: 2, args: [ true ], returns: 0 }, // 0 due to not i32
-      // pointer, value, align, offset
-      f64_store: { imms: 2, args: [ true, false ], returns: 0 },
-
-      // value
-      i32_const: { imms: 1, args: [], returns: 0 },
-    };
+      if (wasmOps[opName]) {
+        const op = wasmOps[opName];
 
-    const opName = name.slice('__Porffor_wasm_'.length);
+        const argOut = [];
+        for (let i = 0; i < op.args.length; i++) argOut.push(
+          ...generate(scope, decl.arguments[i]),
+          ...(op.args[i] ? [ Opcodes.i32_to ] : [])
+        );
 
-    if (wasmOps[opName]) {
-      const op = wasmOps[opName];
+        // literals only
+        const imms = decl.arguments.slice(op.args.length).map(x => x.value);
 
-      const argOut = [];
-      for (let i = 0; i < op.args.length; i++) argOut.push(
-        ...generate(scope, decl.arguments[i]),
-        ...(op.args[i] ? [ Opcodes.i32_to ] : [])
-      );
+        return [
+          ...argOut,
+          [ Opcodes[opName], ...imms ],
+          ...(new Array(op.returns).fill(Opcodes.i32_from))
+        ];
+      }
+    } else {
+      if (!Prefs.indirectCalls) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
 
-      // literals only
-      const imms = decl.arguments.slice(op.args.length).map(x => x.value);
+      // todo: only works when function uses typedParams and typedReturns
 
-      return [
-        ...argOut,
-        [ Opcodes[opName], ...imms ],
-        ...(new Array(op.returns).fill(Opcodes.i32_from))
-      ];
-    }
-  }
+      const indirectMode = Prefs.indirectCallMode ?? 'vararg';
+      // options: vararg, strict
+      // - strict: simpler, smaller size usage, no func 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;
 
-  if (idx === undefined) {
-    if (!Prefs.indirectCalls) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+      let args = decl.arguments;
+      let locals = [];
 
-    // todo: only works when function uses typedParams and typedReturns
+      if (indirectMode === 'vararg') {
+        const minArgc = Prefs.indirectCallMinArgc ?? 3;
 
-    const indirectMode = Prefs.indirectCallMode ?? 'vararg';
-    // options: vararg, strict
-    // - strict: simpler, smaller size usage, no func 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
+        if (args.length < minArgc) {
+          args = args.concat(new Array(minArgc - args.length).fill(DEFAULT_VALUE));
+        }
+      }
 
-    funcs.table = true;
-    scope.table = true;
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        out = out.concat(generate(scope, arg));
 
-    let args = decl.arguments;
-    let locals = [];
+        if (valtypeBinary !== Valtype.i32 && (
+          (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
+          (importedFuncs[name] && name.startsWith('profile'))
+        )) {
+          out.push(Opcodes.i32_to);
+        }
 
-    if (indirectMode === 'vararg') {
-      const minArgc = Prefs.indirectCallMinArgc ?? 3;
+        out = out.concat(getNodeType(scope, arg));
 
-      if (args.length < minArgc) {
-        args = args.concat(new Array(minArgc - args.length).fill(DEFAULT_VALUE));
-      }
-    }
+        if (indirectMode === 'vararg') {
+          const typeLocal = localTmp(scope, `#indirect_arg${i}_type`, Valtype.i32);
+          const valLocal = localTmp(scope, `#indirect_arg${i}_val`);
 
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      out = out.concat(generate(scope, arg));
+          locals.push([valLocal, typeLocal]);
 
-      if (valtypeBinary !== Valtype.i32 && (
-        (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
-        (importedFuncs[name] && name.startsWith('profile'))
-      )) {
-        out.push(Opcodes.i32_to);
+          out.push(
+            [ Opcodes.local_set, typeLocal ],
+            [ Opcodes.local_set, valLocal ]
+          );
+        }
       }
 
-      out = out.concat(getNodeType(scope, arg));
+      if (indirectMode === 'strict') {
+        return [
+          ...generate(scope, decl.callee),
+          [ Opcodes.local_set, localTmp(scope, '#indirect_callee') ],
+
+          ...typeSwitch(scope, getNodeType(scope, decl.callee), {
+            [TYPES.function]: [
+              ...out,
+
+              [ Opcodes.local_get, localTmp(scope, '#indirect_callee') ],
+              ...generate(scope, decl.callee),
+              Opcodes.i32_to_u,
+              [ Opcodes.call_indirect, args.length, 0 ],
+              ...setLastType(scope)
+            ],
+            default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
+          })
+        ];
+      }
 
-      if (indirectMode === 'vararg') {
-        const typeLocal = localTmp(scope, `#indirect_arg${i}_type`, Valtype.i32);
-        const valLocal = localTmp(scope, `#indirect_arg${i}_val`);
+      // 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 flags = localTmp(scope, '#indirect_flags', Valtype.i32);
+
+      const gen = argc => {
+        const argsOut = [];
+        for (let i = 0; i < argc; i++) {
+          argsOut.push(
+            [ Opcodes.local_get, locals[i][0] ],
+            [ Opcodes.local_get, locals[i][1] ]
+          );
+        }
 
-        locals.push([valLocal, typeLocal]);
+        const checkFlag = (flag, pass, fail) => [
+          [ Opcodes.local_get, flags ],
+          ...number(flag, Valtype.i32),
+          [ Opcodes.i32_and ],
+          [ Opcodes.if, valtypeBinary ],
+          ...pass,
+          [ Opcodes.else ],
+          ...fail,
+          [ Opcodes.end ]
+        ];
 
-        out.push(
-          [ Opcodes.local_set, typeLocal ],
-          [ Opcodes.local_set, valLocal ]
+        // pain.
+        // return checkFlag(0b10, [ // constr
+        //   [ Opcodes.i32_const, decl._new ? 1 : 0 ],
+        //   ...argsOut,
+        //   [ Opcodes.local_get, funcLocal ],
+        //   [ Opcodes.call_indirect, argc, 0, 'constr' ],
+        //   ...setLastType(scope),
+        // ], [
+        //   ...argsOut,
+        //   [ Opcodes.local_get, funcLocal ],
+        //   [ Opcodes.call_indirect, argc, 0 ],
+        //   ...setLastType(scope),
+        // ]);
+
+        return checkFlag(0b1, // no type return
+          checkFlag(0b10, [ // no type return & constr
+            [ Opcodes.i32_const, decl._new ? 1 : 0 ],
+            ...argsOut,
+            [ Opcodes.local_get, funcLocal ],
+            [ Opcodes.call_indirect, argc, 0, 'no_type_return', 'constr' ],
+          ], [
+            ...argsOut,
+            [ Opcodes.local_get, funcLocal ],
+            [ Opcodes.call_indirect, argc, 0, 'no_type_return' ]
+          ]),
+          checkFlag(0b10, [ // type return & constr
+            [ Opcodes.i32_const, decl._new ? 1 : 0 ],
+            ...argsOut,
+            [ Opcodes.local_get, funcLocal ],
+            [ Opcodes.call_indirect, argc, 0, 'constr' ],
+            ...setLastType(scope),
+          ], [
+            ...argsOut,
+            [ Opcodes.local_get, funcLocal ],
+            [ Opcodes.call_indirect, argc, 0 ],
+            ...setLastType(scope),
+          ]),
         );
+      };
+
+      const tableBc = {};
+      for (let i = 0; i <= args.length; i++) {
+        tableBc[i] = gen(i);
       }
-    }
 
-    if (indirectMode === 'strict') {
+      // todo/perf: check if we should use br_table here or just generate our own big if..elses
+
       return [
         ...generate(scope, decl.callee),
         [ Opcodes.local_set, localTmp(scope, '#indirect_callee') ],
@@ -2050,145 +2187,42 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
             ...out,
 
             [ Opcodes.local_get, localTmp(scope, '#indirect_callee') ],
-            ...generate(scope, decl.callee),
             Opcodes.i32_to_u,
-            [ Opcodes.call_indirect, args.length, 0 ],
-            ...setLastType(scope)
+            [ Opcodes.local_set, funcLocal ],
+
+            // get if func we are calling is a constructor or not
+            [ Opcodes.local_get, funcLocal ],
+            ...number(3, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            ...number(2, Valtype.i32),
+            [ Opcodes.i32_add ],
+            [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ],
+            [ Opcodes.local_set, flags ],
+
+            // check if non-constructor was called with new, if so throw
+            [ Opcodes.local_get, flags ],
+            ...number(0b10, Valtype.i32),
+            [ Opcodes.i32_and ],
+            [ Opcodes.i32_eqz ],
+            [ Opcodes.i32_const, decl._new ? 1 : 0 ],
+            [ Opcodes.i32_and ],
+            [ Opcodes.if, Blocktype.void ],
+              ...internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`),
+            [ Opcodes.end ],
+
+            ...brTable([
+              // get argc of func we are calling
+              [ Opcodes.local_get, funcLocal ],
+              ...number(3, Valtype.i32),
+              [ Opcodes.i32_mul ],
+              [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ]
+            ], tableBc, valtypeBinary)
           ],
           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 flags = localTmp(scope, '#indirect_flags', Valtype.i32);
-
-    const gen = argc => {
-      const argsOut = [];
-      for (let i = 0; i < argc; i++) {
-        argsOut.push(
-          [ Opcodes.local_get, locals[i][0] ],
-          [ Opcodes.local_get, locals[i][1] ]
-        );
-      }
-
-      const checkFlag = (flag, pass, fail) => [
-        [ Opcodes.local_get, flags ],
-        ...number(flag, Valtype.i32),
-        [ Opcodes.i32_and ],
-        [ Opcodes.if, valtypeBinary ],
-        ...pass,
-        [ Opcodes.else ],
-        ...fail,
-        [ Opcodes.end ]
-      ];
-
-      // pain.
-      // return checkFlag(0b10, [ // constr
-      //   [ Opcodes.i32_const, decl._new ? 1 : 0 ],
-      //   ...argsOut,
-      //   [ Opcodes.local_get, funcLocal ],
-      //   [ Opcodes.call_indirect, argc, 0, 'constr' ],
-      //   ...setLastType(scope),
-      // ], [
-      //   ...argsOut,
-      //   [ Opcodes.local_get, funcLocal ],
-      //   [ Opcodes.call_indirect, argc, 0 ],
-      //   ...setLastType(scope),
-      // ]);
-
-      return checkFlag(0b1, // no type return
-        checkFlag(0b10, [ // no type return & constr
-          [ Opcodes.i32_const, decl._new ? 1 : 0 ],
-          ...argsOut,
-          [ Opcodes.local_get, funcLocal ],
-          [ Opcodes.call_indirect, argc, 0, 'no_type_return', 'constr' ],
-        ], [
-          ...argsOut,
-          [ Opcodes.local_get, funcLocal ],
-          [ Opcodes.call_indirect, argc, 0, 'no_type_return' ]
-        ]),
-        checkFlag(0b10, [ // type return & constr
-          [ Opcodes.i32_const, decl._new ? 1 : 0 ],
-          ...argsOut,
-          [ Opcodes.local_get, funcLocal ],
-          [ Opcodes.call_indirect, argc, 0, 'constr' ],
-          ...setLastType(scope),
-        ], [
-          ...argsOut,
-          [ Opcodes.local_get, funcLocal ],
-          [ Opcodes.call_indirect, argc, 0 ],
-          ...setLastType(scope),
-        ]),
-      );
-    };
-
-    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 [
-      ...generate(scope, decl.callee),
-      [ Opcodes.local_set, localTmp(scope, '#indirect_callee') ],
-
-      ...typeSwitch(scope, getNodeType(scope, decl.callee), {
-        [TYPES.function]: [
-          ...out,
-
-          [ Opcodes.local_get, localTmp(scope, '#indirect_callee') ],
-          Opcodes.i32_to_u,
-          [ Opcodes.local_set, funcLocal ],
-
-          // get if func we are calling is a constructor or not
-          [ Opcodes.local_get, funcLocal ],
-          ...number(3, Valtype.i32),
-          [ Opcodes.i32_mul ],
-          ...number(2, Valtype.i32),
-          [ Opcodes.i32_add ],
-          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ],
-          [ Opcodes.local_set, flags ],
-
-          // check if non-constructor was called with new, if so throw
-          [ Opcodes.local_get, flags ],
-          ...number(0b10, Valtype.i32),
-          [ Opcodes.i32_and ],
-          [ Opcodes.i32_eqz ],
-          [ Opcodes.i32_const, decl._new ? 1 : 0 ],
-          [ Opcodes.i32_and ],
-          [ Opcodes.if, Blocktype.void ],
-            ...internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`),
-          [ Opcodes.end ],
-
-          ...brTable([
-            // get argc of func we are calling
-            [ Opcodes.local_get, funcLocal ],
-            ...number(3, Valtype.i32),
-            [ Opcodes.i32_mul ],
-            [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ]
-          ], tableBc, valtypeBinary)
-        ],
-        default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
-      })
-    ];
-  }
-
   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;
@@ -2464,7 +2498,7 @@ const allocVar = (scope, name, global = false, type = true) => {
   const target = global ? globals : scope.locals;
 
   // already declared
-  if (target[name]) {
+  if (Object.hasOwn(target, name)) {
     // parser should catch this but sanity check anyway
     // if (decl.kind !== 'var') return internalThrow(scope, 'SyntaxError', `Identifier '${unhackName(name)}' has already been declared`);
 
@@ -2660,7 +2694,7 @@ const generateVar = (scope, decl) => {
       continue;
     }
 
-    if (topLevel && builtinVars[name]) {
+    if (topLevel && Object.hasOwn(builtinVars, name)) {
       // cannot redeclare
       if (decl.kind !== 'var') return internalThrow(scope, 'SyntaxError', `Identifier '${unhackName(name)}' has already been declared`);
 
@@ -2681,21 +2715,23 @@ const generateVar = (scope, decl) => {
     if (x.init) {
       const alreadyArray = scope.arrays?.get(name) != null;
 
-      const generated = generate(scope, x.init, global, name);
+      const newOut = generate(scope, x.init, global, name);
       if (!alreadyArray && scope.arrays?.get(name) != null) {
         // hack to set local as pointer before
-        out.push(...number(scope.arrays.get(name)), [ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
-        if (generated.at(-1) == Opcodes.i32_from_u) generated.pop();
-        // generated.pop();
-        generated.push([ Opcodes.drop ]);
-
-        out = out.concat(generated);
+        newOut.unshift(...number(scope.arrays.get(name)), [ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
+        if (newOut.at(-1) == Opcodes.i32_from_u) newOut.pop();
+        newOut.push([ Opcodes.drop ]);
       } else {
-        out = out.concat(generated);
-        out.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
+        newOut.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
       }
 
-      out.push(...setType(scope, name, getNodeType(scope, x.init)));
+      newOut.push(...setType(scope, name, getNodeType(scope, x.init)));
+      out = out.concat(newOut);
+
+      if (globalThis.precompile && global) {
+        scope.globalInits ??= {};
+        scope.globalInits[name] = newOut;
+      }
     }
 
     // hack: this follows spec properly but is mostly unneeded 😅
@@ -2994,7 +3030,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
     // only allow = for this
     if (op !== '=') return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`);
 
-    if (builtinVars[name]) {
+    if (Object.hasOwn(builtinVars, name)) {
       // just return rhs (eg `NaN = 2`)
       return generate(scope, decl.right);
     }
@@ -3045,6 +3081,15 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   ];
 };
 
+const ifIdentifierErrors = (scope, decl) => {
+  if (decl.type === 'Identifier') {
+    const out = generateIdent(scope, decl);
+    if (out[1]) return true;
+  }
+
+  return false;
+};
+
 const generateUnary = (scope, decl) => {
   switch (decl.operator) {
     case '+':
@@ -3118,16 +3163,9 @@ const generateUnary = (scope, decl) => {
 
     case 'typeof': {
       let overrideType, toGenerate = true;
-
-      if (decl.argument.type === 'Identifier') {
-        const out = generateIdent(scope, decl.argument);
-
-        // if ReferenceError (undeclared var), ignore and return undefined
-        if (out[1]) {
-          // does not exist (2 ops from throw)
-          overrideType = number(TYPES.undefined, Valtype.i32);
-          toGenerate = false;
-        }
+      if (ifIdentifierErrors(scope, decl.argument)) {
+        overrideType = number(TYPES.undefined, Valtype.i32);
+        toGenerate = false;
       }
 
       const out = toGenerate ? generate(scope, decl.argument) : [];
@@ -4321,15 +4359,17 @@ const generateMember = (scope, decl, _global, _name) => {
 
   // hack: .length
   if (decl.property.name === 'length') {
+    // todo: support optional
+
     const func = funcs.find(x => x.name === name);
     if (func) {
       const typedParams = !func.internal || builtinFuncs[name]?.typedParams;
       return withType(scope, number(typedParams ? Math.floor(func.params.length / 2) : (func.constr ? (func.params.length - 1) : func.params.length)), TYPES.number);
     }
 
-    if (builtinFuncs[name]) return withType(scope, number(builtinFuncs[name].typedParams ? Math.floor(builtinFuncs[name].params.length / 2) : (builtinFuncs[name].constr ? (builtinFuncs[name].params.length - 1) : builtinFuncs[name].params.length)), TYPES.number);
-    if (importedFuncs[name]) return withType(scope, number(importedFuncs[name].params.length ?? importedFuncs[name].params), TYPES.number);
-    if (internalConstrs[name]) return withType(scope, number(internalConstrs[name].length ?? 0), TYPES.number);
+    if (Object.hasOwn(builtinFuncs, name)) return withType(scope, number(builtinFuncs[name].typedParams ? Math.floor(builtinFuncs[name].params.length / 2) : (builtinFuncs[name].constr ? (builtinFuncs[name].params.length - 1) : builtinFuncs[name].params.length)), TYPES.number);
+    if (Object.hasOwn(importedFuncs, name)) return withType(scope, number(importedFuncs[name].params.length ?? importedFuncs[name].params), TYPES.number);
+    if (Object.hasOwn(internalConstrs, name)) return withType(scope, number(internalConstrs[name].length ?? 0), TYPES.number);
 
     const out = [
       ...generate(scope, decl.object),
@@ -4381,6 +4421,7 @@ const generateMember = (scope, decl, _global, _name) => {
 
   // todo: generate this array procedurally during builtinFuncs creation
   if (['size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength'].includes(decl.property.name)) {
+    // todo: support optional
     const bc = {};
     const cands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + decl.property.name + '$get'));
 
@@ -4407,12 +4448,13 @@ const generateMember = (scope, decl, _global, _name) => {
   }
 
   const object = decl.object;
-  const objectWasm = generate(scope, object);
   const property = decl.computed ? decl.property : {
     type: 'Literal',
     value: decl.property.name
   };
-  const propertyWasm = generate(scope, property);
+
+  const objectWasm = [ [ Opcodes.local_get, localTmp(scope, '#member_obj') ] ];
+  const propertyWasm = [ [ Opcodes.local_get, localTmp(scope, '#member_prop') ] ];
 
   // // todo: we should only do this for strings but we don't know at compile-time :(
   // hack: this is naughty and will break things!
@@ -4428,7 +4470,7 @@ const generateMember = (scope, decl, _global, _name) => {
 
   includeBuiltin(scope, '__Map_prototype_get');
 
-  return typeSwitch(scope, getNodeType(scope, object), {
+  const out = typeSwitch(scope, getNodeType(scope, object), {
     [TYPES.array]: [
       ...loadArray(scope, objectWasm, propertyWasm),
       ...setLastType(scope)
@@ -4588,6 +4630,38 @@ const generateMember = (scope, decl, _global, _name) => {
 
     default: internalThrow(scope, 'TypeError', 'Unsupported member expression object', true)
   });
+
+  if (decl.optional) {
+    out.unshift(
+      [ Opcodes.block, valtypeBinary ],
+      ...generate(scope, object),
+      [ Opcodes.local_tee, localTmp(scope, '#member_obj') ],
+
+      ...nullish(scope, [], getNodeType(scope, object), false, true),
+      [ Opcodes.if, Blocktype.void ],
+      ...setLastType(scope, TYPES.undefined),
+      ...number(0),
+      [ Opcodes.br, 1 ],
+      [ Opcodes.end ],
+
+      ...generate(scope, property),
+      [ Opcodes.local_set, localTmp(scope, '#member_prop') ]
+    );
+
+    out.push(
+      [ Opcodes.end ]
+    );
+  } else {
+    out.unshift(
+      ...generate(scope, object),
+      [ Opcodes.local_set, localTmp(scope, '#member_obj') ],
+
+      ...generate(scope, property),
+      [ Opcodes.local_set, localTmp(scope, '#member_prop') ]
+    );
+  }
+
+  return out;
 };
 
 const randId = () => Math.random().toString(16).slice(1, -2).padEnd(12, '0');