porffor 0.19.8 → 0.19.9

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 ];
 };
@@ -1273,14 +1273,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 +1293,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 +1342,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 +1356,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 +1601,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 +1931,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
 
-  if (idx === undefined) {
-    if (!Prefs.indirectCalls) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+      funcs.table = true;
+      scope.table = true;
 
-    // todo: only works when function uses typedParams and typedReturns
+      let args = decl.arguments;
+      let locals = [];
 
-    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 (indirectMode === 'vararg') {
+        const minArgc = Prefs.indirectCallMinArgc ?? 3;
 
-    funcs.table = true;
-    scope.table = true;
+        if (args.length < minArgc) {
+          args = args.concat(new Array(minArgc - args.length).fill(DEFAULT_VALUE));
+        }
+      }
 
-    let args = decl.arguments;
-    let locals = [];
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        out = out.concat(generate(scope, arg));
 
-    if (indirectMode === 'vararg') {
-      const minArgc = Prefs.indirectCallMinArgc ?? 3;
+        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 (args.length < minArgc) {
-        args = args.concat(new Array(minArgc - args.length).fill(DEFAULT_VALUE));
-      }
-    }
+        out = out.concat(getNodeType(scope, arg));
+
+        if (indirectMode === 'vararg') {
+          const typeLocal = localTmp(scope, `#indirect_arg${i}_type`, Valtype.i32);
+          const valLocal = localTmp(scope, `#indirect_arg${i}_val`);
 
-    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 +2153,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 +2464,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 +2660,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`);
 
@@ -2994,7 +2994,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 +3045,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 +3127,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 +4323,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 +4385,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 +4412,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 +4434,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 +4594,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');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.19.8+92c5cf593",
+  "version": "0.19.9+a07f4dac1",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.19.8+92c5cf593';
+globalThis.version = '0.19.9+a07f4dac1';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {