porffor 0.20.6 → 0.20.8

package/compiler/codegen.js

@@ -41,16 +41,23 @@ const isFuncType = type =>
 const hasFuncWithName = name =>
   Object.hasOwn(funcIndex, name) != null || Object.hasOwn(builtinFuncs, name) != null || Object.hasOwn(importedFuncs, name) != null || Object.hasOwn(internalConstrs, name) != null;
 
+const astCache = new WeakMap();
+const cacheAst = (decl, wasm) => {
+  astCache.set(decl, wasm);
+  return wasm;
+};
 const generate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
+  if (astCache.has(decl)) return astCache.get(decl);
+
   switch (decl.type) {
     case 'BinaryExpression':
-      return generateBinaryExp(scope, decl, global, name);
+      return cacheAst(decl, generateBinaryExp(scope, decl, global, name));
 
     case 'LogicalExpression':
-      return generateLogicExp(scope, decl);
+      return cacheAst(decl, generateLogicExp(scope, decl));
 
     case 'Identifier':
-      return generateIdent(scope, decl);
+      return cacheAst(decl, generateIdent(scope, decl));
 
     case 'ArrowFunctionExpression':
     case 'FunctionDeclaration':
@@ -58,101 +65,100 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
       const func = generateFunc(scope, decl);
 
       if (decl.type.endsWith('Expression')) {
-        return number(func.index - importedFuncs.length);
+        return cacheAst(decl, number(func.index - importedFuncs.length));
       }
 
-      return [];
+      return cacheAst(decl, []);
 
     case 'BlockStatement':
-      return generateCode(scope, decl);
+      return cacheAst(decl, generateCode(scope, decl));
 
     case 'ReturnStatement':
-      return generateReturn(scope, decl);
+      return cacheAst(decl, generateReturn(scope, decl))
 
     case 'ExpressionStatement':
-      return generateExp(scope, decl);
+      return cacheAst(decl, generateExp(scope, decl))
 
     case 'SequenceExpression':
-      return generateSequence(scope, decl);
+      return cacheAst(decl, generateSequence(scope, decl))
 
     case 'ChainExpression':
-      return generateChain(scope, decl);
+      return cacheAst(decl, generateChain(scope, decl))
 
     case 'CallExpression':
-      return generateCall(scope, decl, global, name, valueUnused);
+      return cacheAst(decl, generateCall(scope, decl, global, name, valueUnused))
 
     case 'NewExpression':
-      return generateNew(scope, decl, global, name);
+      return cacheAst(decl, generateNew(scope, decl, global, name))
 
     case 'Literal':
-      return generateLiteral(scope, decl, global, name);
+      return cacheAst(decl, generateLiteral(scope, decl, global, name))
 
     case 'VariableDeclaration':
-      return generateVar(scope, decl);
+      return cacheAst(decl, generateVar(scope, decl))
 
     case 'AssignmentExpression':
-      return generateAssign(scope, decl);
+      return cacheAst(decl, generateAssign(scope, decl))
 
     case 'UnaryExpression':
-      return generateUnary(scope, decl);
+      return cacheAst(decl, generateUnary(scope, decl))
 
     case 'UpdateExpression':
-      return generateUpdate(scope, decl, global, name, valueUnused);
+      return cacheAst(decl, generateUpdate(scope, decl, global, name, valueUnused))
 
     case 'IfStatement':
-      return generateIf(scope, decl);
+      return cacheAst(decl, generateIf(scope, decl))
 
     case 'ForStatement':
-      return generateFor(scope, decl);
+      return cacheAst(decl, generateFor(scope, decl))
 
     case 'WhileStatement':
-      return generateWhile(scope, decl);
+      return cacheAst(decl, generateWhile(scope, decl))
 
     case 'DoWhileStatement':
-      return generateDoWhile(scope, decl);
+      return cacheAst(decl, generateDoWhile(scope, decl))
 
     case 'ForOfStatement':
-      return generateForOf(scope, decl);
+      return cacheAst(decl, generateForOf(scope, decl))
 
     case 'SwitchStatement':
-      return generateSwitch(scope, decl);
+      return cacheAst(decl, generateSwitch(scope, decl))
 
     case 'BreakStatement':
-      return generateBreak(scope, decl);
+      return cacheAst(decl, generateBreak(scope, decl))
 
     case 'ContinueStatement':
-      return generateContinue(scope, decl);
+      return cacheAst(decl, generateContinue(scope, decl))
 
     case 'LabeledStatement':
-      return generateLabel(scope, decl);
+      return cacheAst(decl, generateLabel(scope, decl))
 
     case 'EmptyStatement':
-      return generateEmpty(scope, decl);
+      return cacheAst(decl, generateEmpty(scope, decl))
 
     case 'MetaProperty':
-      return generateMeta(scope, decl);
+      return cacheAst(decl, generateMeta(scope, decl))
 
     case 'ConditionalExpression':
-      return generateConditional(scope, decl);
+      return cacheAst(decl, generateConditional(scope, decl))
 
     case 'ThrowStatement':
-      return generateThrow(scope, decl);
+      return cacheAst(decl, generateThrow(scope, decl))
 
     case 'TryStatement':
-      return generateTry(scope, decl);
+      return cacheAst(decl, generateTry(scope, decl))
 
     case 'DebuggerStatement':
-      // todo: hook into terminal debugger
-      return [[ Opcodes.call, importedFuncs.debugger ]];
+      return cacheAst(decl, [[ Opcodes.call, importedFuncs.debugger ]])
 
     case 'ArrayExpression':
-      return generateArray(scope, decl, global, name);
+      return cacheAst(decl, generateArray(scope, decl, global, name))
 
     case 'ObjectExpression':
-      return generateObject(scope, decl, global, name);
+      return cacheAst(decl, generateObject(scope, decl, global, name))
 
     case 'MemberExpression':
-      return generateMember(scope, decl, global, name);
+      return cacheAst(decl, generateMember(scope, decl, global, name))
 
     case 'ExportNamedDeclaration':
       const funcsBefore = funcs.map(x => x.name);
@@ -167,7 +173,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
         }
       }
 
-      return [];
+      return cacheAst(decl, [])
 
     case 'TaggedTemplateExpression': {
       const funcs = {
@@ -191,8 +197,8 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
             let inst = Opcodes[asm[0].replace('.', '_')];
             if (inst == null) throw new Error(`inline asm: inst ${asm[0]} not found`);
-
             if (!Array.isArray(inst)) inst = [ inst ];
+
             const immediates = asm.slice(1).map(x => {
               const int = parseInt(x);
               if (Number.isNaN(int)) {
@@ -206,7 +212,11 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
               return int;
             });
 
-            out.push([ ...inst, ...immediates.flatMap(x => signedLEB128(x)) ]);
+            const encodeFunc = ({
+              [Opcodes.f64_const]: ieee754_binary64,
+              [Opcodes.if]: unsignedLEB128
+            })[inst[0]] ?? signedLEB128;
+            out.push([ ...inst, ...immediates.flatMap(x => encodeFunc(x)) ]);
           }
 
           return out;
@@ -218,7 +228,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
       const func = decl.tag.name;
       // hack for inline asm
-      if (!funcs[func]) return todo(scope, 'tagged template expressions not implemented', true);
+      if (!funcs[func]) return cacheAst(decl, todo(scope, 'tagged template expressions not implemented', true))
 
       const { quasis, expressions } = decl.quasi;
       let str = quasis[0].value.raw;
@@ -234,17 +244,17 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
         str += quasis[i + 1].value.raw;
       }
 
-      return funcs[func](str);
+      return cacheAst(decl, funcs[func](str))
     }
 
     default:
       // ignore typescript nodes
       if (decl.type.startsWith('TS') ||
           decl.type === 'ImportDeclaration' && decl.importKind === 'type') {
-        return [];
+        return cacheAst(decl, [])
       }
 
-      return todo(scope, `no generation for ${decl.type}!`);
+      return cacheAst(decl, todo(scope, `no generation for ${decl.type}!`))
   }
 };
 
@@ -1196,7 +1206,12 @@ const asmFuncToAsm = (scope, func) => {
   });
 };
 
-const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits = [], returns, returnType, localNames = [], globalNames = [], data: _data = [], table = false, constr = false, hasRestArgument = false }) => {
+const asmFunc = (name, { wasm, params = [], locals: localTypes = [], globals: globalTypes = [], globalInits = [], returns = [], returnType, localNames = [], globalNames = [], data: _data = [], table = false, constr = false, hasRestArgument = false } = {}) => {
+  if (wasm == null) { // called with no builtin
+    log.warning('codegen', `${name} has no built-in!`);
+    wasm = [];
+  }
+
   const existing = funcs.find(x => x.name === name);
   if (existing) return existing;
 
@@ -1332,7 +1347,7 @@ const isExistingProtoFunc = name => {
 const getType = (scope, _name) => {
   const name = mapName(_name);
 
-  // if (scope.locals[name] && !scope.locals[name + '#type']) console.log(name);
+  if (Object.hasOwn(builtinVars, name)) return number(builtinVars[name].type ?? TYPES.number, Valtype.i32);
 
   if (typedInput && scope.locals[name]?.metadata?.type != null) return number(scope.locals[name].metadata.type, Valtype.i32);
   if (Object.hasOwn(scope.locals, name)) return [ [ Opcodes.local_get, scope.locals[name + '#type'].idx ] ];
@@ -1340,13 +1355,13 @@ const getType = (scope, _name) => {
   if (typedInput && globals[name]?.metadata?.type != null) return number(globals[name].metadata.type, Valtype.i32);
   if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name + '#type'].idx ] ];
 
-  let type = TYPES.undefined;
-  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 (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(importedFuncs, name) ||
+      Object.hasOwn(funcIndex, name) || Object.hasOwn(internalConstrs, name))
+        return number(TYPES.function, Valtype.i32);
 
-  if (isExistingProtoFunc(name)) type = TYPES.function;
+  if (isExistingProtoFunc(name)) return number(TYPES.function, Valtype.i32);
 
-  return number(type, Valtype.i32);
+  return number(TYPES.undefined, Valtype.i32);
 };
 
 const setType = (scope, _name, type) => {
@@ -2863,226 +2878,231 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
       value: decl.left.property.name
     };
 
-    return [
-      ...typeSwitch(scope, getNodeType(scope, decl.left.object), {
-        [TYPES.array]: [
-          ...generate(scope, object),
-          Opcodes.i32_to_u,
+    // todo: review last type usage here
 
-          // get index as valtype
-          ...generate(scope, property),
-          Opcodes.i32_to_u,
+    return typeSwitch(scope, getNodeType(scope, decl.left.object), {
+      [TYPES.array]: [
+        ...generate(scope, object),
+        Opcodes.i32_to_u,
 
-          // turn into byte offset by * valtypeSize + 1
-          ...number(ValtypeSize[valtype] + 1, Valtype.i32),
-          [ Opcodes.i32_mul ],
-          [ Opcodes.i32_add ],
-          [ Opcodes.local_tee, pointerTmp ],
+        // get index as valtype
+        ...generate(scope, property),
+        Opcodes.i32_to_u,
 
-          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-            [ Opcodes.local_get, pointerTmp ],
-            [ Opcodes.load, 0, ValtypeSize.i32 ]
-          ], generate(scope, decl.right), [
-            [ Opcodes.local_get, pointerTmp ],
-            [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
-          ], getNodeType(scope, decl.right), false, name, true)),
-          [ Opcodes.local_tee, newValueTmp ],
-          [ Opcodes.store, 0, ValtypeSize.i32 ],
+        // turn into byte offset by * valtypeSize + 1
+        ...number(ValtypeSize[valtype] + 1, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_tee, pointerTmp ],
 
+        ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
           [ Opcodes.local_get, pointerTmp ],
-          ...getNodeType(scope, decl),
-          [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
-        ],
+          [ Opcodes.load, 0, ValtypeSize.i32 ]
+        ], generate(scope, decl.right), [
+          [ Opcodes.local_get, pointerTmp ],
+          [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
+        ], getNodeType(scope, decl.right), false, name, true)),
+        [ Opcodes.local_tee, newValueTmp ],
+        [ Opcodes.store, 0, ValtypeSize.i32 ],
 
-        [TYPES.object]: [
-          ...generate(scope, object),
-          ...(op === '=' ? [] : [ [ Opcodes.local_tee, localTmp(scope, '#objset_object') ] ]),
-          ...getNodeType(scope, object),
+        [ Opcodes.local_get, pointerTmp ],
+        ...getNodeType(scope, decl),
+        [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
 
-          ...generate(scope, property),
-          ...getNodeType(scope, property),
-          ...toPropertyKey(scope),
-          ...(op === '=' ? [] : [ [ Opcodes.local_set, localTmp(scope, '#objset_property_type', Valtype.i32) ] ]),
-          ...(op === '=' ? [] : [ [ Opcodes.local_tee, localTmp(scope, '#objset_property') ] ]),
-          ...(op === '=' ? [] : [ [ Opcodes.local_get, localTmp(scope, '#objset_property_type', Valtype.i32) ] ]),
+        [ Opcodes.local_get, newValueTmp ]
+      ],
 
-          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-            [ Opcodes.local_get, localTmp(scope, '#objset_object') ],
-            ...getNodeType(scope, object),
+      [TYPES.object]: [
+        ...generate(scope, object),
+        Opcodes.i32_to_u,
+        ...(op === '=' ? [] : [ [ Opcodes.local_tee, localTmp(scope, '#objset_object', Valtype.i32) ] ]),
+        ...getNodeType(scope, object),
+
+        ...generate(scope, property),
+        ...getNodeType(scope, property),
+        ...toPropertyKey(scope, op === '='),
+        ...(op === '=' ? [] : [ [ Opcodes.local_set, localTmp(scope, '#objset_property_type', Valtype.i32) ] ]),
+        ...(op === '=' ? [] : [
+          Opcodes.i32_to_u,
+          [ Opcodes.local_tee, localTmp(scope, '#objset_property', Valtype.i32) ]
+        ]),
+        ...(op === '=' ? [] : [ [ Opcodes.local_get, localTmp(scope, '#objset_property_type', Valtype.i32) ] ]),
 
-            [ Opcodes.local_get, localTmp(scope, '#objset_property') ],
-            [ Opcodes.local_get, localTmp(scope, '#objset_property_type', Valtype.i32) ],
+        ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+          [ Opcodes.local_get, localTmp(scope, '#objset_object', Valtype.i32) ],
+          ...getNodeType(scope, object),
 
-            [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Map_prototype_get').index) ],
-            ...setLastType(scope)
-          ], generate(scope, decl.right), getLastType(scope), getNodeType(scope, decl.right), false, name, true)),
-          [ Opcodes.local_tee, newValueTmp ],
-          ...getNodeType(scope, decl),
+          [ Opcodes.local_get, localTmp(scope, '#objset_property', Valtype.i32) ],
+          [ Opcodes.local_get, localTmp(scope, '#objset_property_type', Valtype.i32) ],
 
-          [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Map_prototype_set').index) ],
-          [ Opcodes.drop ],
+          [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Porffor_object_get').index) ],
+          ...setLastType(scope)
+        ], generate(scope, decl.right), getLastType(scope), getNodeType(scope, decl.right), false, name, true)),
+        ...getNodeType(scope, decl),
 
-          ...setLastType(scope, getNodeType(scope, decl)),
-        ],
+        [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Porffor_object_set').index) ],
+        [ Opcodes.drop ],
+        // ...setLastType(scope, getNodeType(scope, decl)),
+      ],
 
-        ...wrapBC({
-          [TYPES.uint8array]: [
-            [ Opcodes.i32_add ],
-            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+      ...wrapBC({
+        [TYPES.uint8array]: [
+          [ Opcodes.i32_add ],
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-              [ Opcodes.local_get, pointerTmp ],
-              [ Opcodes.i32_load8_u, 0, 4 ],
-              Opcodes.i32_from_u
-            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
-            [ Opcodes.local_tee, newValueTmp ],
+          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.i32_load8_u, 0, 4 ],
+            Opcodes.i32_from_u
+          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+          [ Opcodes.local_tee, newValueTmp ],
 
-            Opcodes.i32_to_u,
-            [ Opcodes.i32_store8, 0, 4 ]
-          ],
-          [TYPES.uint8clampedarray]: [
-            [ Opcodes.i32_add ],
-            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
-
-            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-              [ Opcodes.local_get, pointerTmp ],
-              [ Opcodes.i32_load8_u, 0, 4 ],
-              Opcodes.i32_from_u
-            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
-            [ Opcodes.local_tee, newValueTmp ],
-
-            ...number(0),
-            [ Opcodes.f64_max ],
-            ...number(255),
-            [ Opcodes.f64_min ],
-            Opcodes.i32_to_u,
-            [ Opcodes.i32_store8, 0, 4 ]
-          ],
-          [TYPES.int8array]: [
-            [ Opcodes.i32_add ],
-            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+          Opcodes.i32_to_u,
+          [ Opcodes.i32_store8, 0, 4 ]
+        ],
+        [TYPES.uint8clampedarray]: [
+          [ Opcodes.i32_add ],
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-              [ Opcodes.local_get, pointerTmp ],
-              [ Opcodes.i32_load8_s, 0, 4 ],
-              Opcodes.i32_from
-            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
-            [ Opcodes.local_tee, newValueTmp ],
+          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.i32_load8_u, 0, 4 ],
+            Opcodes.i32_from_u
+          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+          [ Opcodes.local_tee, newValueTmp ],
 
-            Opcodes.i32_to,
-            [ Opcodes.i32_store8, 0, 4 ]
-          ],
-          [TYPES.uint16array]: [
-            ...number(2, Valtype.i32),
-            [ Opcodes.i32_mul ],
-            [ Opcodes.i32_add ],
-            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+          ...number(0),
+          [ Opcodes.f64_max ],
+          ...number(255),
+          [ Opcodes.f64_min ],
+          Opcodes.i32_to_u,
+          [ Opcodes.i32_store8, 0, 4 ]
+        ],
+        [TYPES.int8array]: [
+          [ Opcodes.i32_add ],
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-              [ Opcodes.local_get, pointerTmp ],
-              [ Opcodes.i32_load16_u, 0, 4 ],
-              Opcodes.i32_from_u
-            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
-            [ Opcodes.local_tee, newValueTmp ],
+          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.i32_load8_s, 0, 4 ],
+            Opcodes.i32_from
+          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+          [ Opcodes.local_tee, newValueTmp ],
 
-            Opcodes.i32_to_u,
-            [ Opcodes.i32_store16, 0, 4 ]
-          ],
-          [TYPES.int16array]: [
-            ...number(2, Valtype.i32),
-            [ Opcodes.i32_mul ],
-            [ Opcodes.i32_add ],
-            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+          Opcodes.i32_to,
+          [ Opcodes.i32_store8, 0, 4 ]
+        ],
+        [TYPES.uint16array]: [
+          ...number(2, Valtype.i32),
+          [ Opcodes.i32_mul ],
+          [ Opcodes.i32_add ],
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-              [ Opcodes.local_get, pointerTmp ],
-              [ Opcodes.i32_load16_s, 0, 4 ],
-              Opcodes.i32_from
-            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
-            [ Opcodes.local_tee, newValueTmp ],
+          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.i32_load16_u, 0, 4 ],
+            Opcodes.i32_from_u
+          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+          [ Opcodes.local_tee, newValueTmp ],
 
-            Opcodes.i32_to,
-            [ Opcodes.i32_store16, 0, 4 ]
-          ],
-          [TYPES.uint32array]: [
-            ...number(4, Valtype.i32),
-            [ Opcodes.i32_mul ],
-            [ Opcodes.i32_add ],
-            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+          Opcodes.i32_to_u,
+          [ Opcodes.i32_store16, 0, 4 ]
+        ],
+        [TYPES.int16array]: [
+          ...number(2, Valtype.i32),
+          [ Opcodes.i32_mul ],
+          [ Opcodes.i32_add ],
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-              [ Opcodes.local_get, pointerTmp ],
-              [ Opcodes.i32_load, 0, 4 ],
-              Opcodes.i32_from_u
-            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
-            [ Opcodes.local_tee, newValueTmp ],
+          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.i32_load16_s, 0, 4 ],
+            Opcodes.i32_from
+          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+          [ Opcodes.local_tee, newValueTmp ],
 
-            Opcodes.i32_to_u,
-            [ Opcodes.i32_store, 0, 4 ]
-          ],
-          [TYPES.int32array]: [
-            ...number(4, Valtype.i32),
-            [ Opcodes.i32_mul ],
-            [ Opcodes.i32_add ],
-            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+          Opcodes.i32_to,
+          [ Opcodes.i32_store16, 0, 4 ]
+        ],
+        [TYPES.uint32array]: [
+          ...number(4, Valtype.i32),
+          [ Opcodes.i32_mul ],
+          [ Opcodes.i32_add ],
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-              [ Opcodes.local_get, pointerTmp ],
-              [ Opcodes.i32_load, 0, 4 ],
-              Opcodes.i32_from
-            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
-            [ Opcodes.local_tee, newValueTmp ],
+          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.i32_load, 0, 4 ],
+            Opcodes.i32_from_u
+          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+          [ Opcodes.local_tee, newValueTmp ],
 
-            Opcodes.i32_to,
-            [ Opcodes.i32_store, 0, 4 ]
-          ],
-          [TYPES.float32array]: [
-            ...number(4, Valtype.i32),
-            [ Opcodes.i32_mul ],
-            [ Opcodes.i32_add ],
-            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+          Opcodes.i32_to_u,
+          [ Opcodes.i32_store, 0, 4 ]
+        ],
+        [TYPES.int32array]: [
+          ...number(4, Valtype.i32),
+          [ Opcodes.i32_mul ],
+          [ Opcodes.i32_add ],
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-              [ Opcodes.local_get, pointerTmp ],
-              [ Opcodes.f32_load, 0, 4 ],
-              [ Opcodes.f64_promote_f32 ]
-            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
-            [ Opcodes.local_tee, newValueTmp ],
+          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.i32_load, 0, 4 ],
+            Opcodes.i32_from
+          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+          [ Opcodes.local_tee, newValueTmp ],
 
-            [ Opcodes.f32_demote_f64 ],
-            [ Opcodes.f32_store, 0, 4 ]
-          ],
-          [TYPES.float64array]: [
-            ...number(8, Valtype.i32),
-            [ Opcodes.i32_mul ],
-            [ Opcodes.i32_add ],
-            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+          Opcodes.i32_to,
+          [ Opcodes.i32_store, 0, 4 ]
+        ],
+        [TYPES.float32array]: [
+          ...number(4, Valtype.i32),
+          [ Opcodes.i32_mul ],
+          [ Opcodes.i32_add ],
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
-              [ Opcodes.local_get, pointerTmp ],
-              [ Opcodes.f64_load, 0, 4 ]
-            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
-            [ Opcodes.local_tee, newValueTmp ],
+          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.f32_load, 0, 4 ],
+            [ Opcodes.f64_promote_f32 ]
+          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+          [ Opcodes.local_tee, newValueTmp ],
 
-            [ Opcodes.f64_store, 0, 4 ]
-          ],
-        }, {
-          prelude: [
-            ...generate(scope, object),
-            Opcodes.i32_to_u,
-            [ Opcodes.i32_load, 0, 4 ],
+          [ Opcodes.f32_demote_f64 ],
+          [ Opcodes.f32_store, 0, 4 ]
+        ],
+        [TYPES.float64array]: [
+          ...number(8, Valtype.i32),
+          [ Opcodes.i32_mul ],
+          [ Opcodes.i32_add ],
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-            ...generate(scope, property),
-            Opcodes.i32_to_u,
-          ],
-          postlude: setLastType(scope, TYPES.number)
-        }),
+          ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+            [ Opcodes.local_get, pointerTmp ],
+            [ Opcodes.f64_load, 0, 4 ]
+          ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+          [ Opcodes.local_tee, newValueTmp ],
 
-        default: internalThrow(scope, 'TypeError', `Cannot assign member with non-array`)
-      }, Blocktype.void),
+          [ Opcodes.f64_store, 0, 4 ]
+        ],
+      }, {
+        prelude: [
+          ...generate(scope, object),
+          Opcodes.i32_to_u,
+          [ Opcodes.i32_load, 0, 4 ],
 
-      [ Opcodes.local_get, newValueTmp ]
-    ];
+          ...generate(scope, property),
+          Opcodes.i32_to_u,
+        ],
+        postlude: [
+          // setLastType(scope, TYPES.number)
+          [ Opcodes.local_get, newValueTmp ]
+        ]
+      }),
+
+      default: internalThrow(scope, 'TypeError', `Cannot assign member with non-array`)
+    }, valtypeBinary);
   }
 
   if (!name) return todo(scope, 'destructuring is not supported yet', true);
@@ -3430,16 +3450,22 @@ const generateForOf = (scope, decl) => {
     // get length
     [ Opcodes.local_get, pointer ],
     [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-    [ Opcodes.local_set, length ]
+    [ Opcodes.local_tee, length ],
+
+    [ Opcodes.if, Blocktype.void ]
   );
 
+  depth.push('if');
   depth.push('forof');
+  depth.push('block');
+  depth.push('block');
 
   // setup local for left
   generate(scope, decl.left);
 
   let leftName = decl.left.declarations?.[0]?.id?.name;
   if (!leftName && decl.left.name) {
+    // todo: should be sloppy mode only
     leftName = decl.left.name;
 
     generateVar(scope, { kind: 'var', _bare: true, declarations: [ { id: { name: leftName } } ] })
@@ -3450,9 +3476,6 @@ const generateForOf = (scope, decl) => {
   const [ local, isGlobal ] = lookupName(scope, leftName);
   if (!local) return todo(scope, 'for of failed to get left local (probably destructure)');
 
-  depth.push('block');
-  depth.push('block');
-
   // // todo: we should only do this for strings but we don't know at compile-time :(
   // hack: this is naughty and will break things!
   let newOut = number(0, Valtype.i32), newPointer = number(0, Valtype.i32);
@@ -3595,12 +3618,6 @@ const generateForOf = (scope, decl) => {
       ...generate(scope, decl.body),
       [ Opcodes.end ],
 
-      // increment iter pointer
-      // [ Opcodes.local_get, pointer ],
-      // ...number(1, Valtype.i32),
-      // [ Opcodes.i32_add ],
-      // [ Opcodes.local_set, pointer ],
-
       // increment counter by 1
       [ Opcodes.local_get, counter ],
       ...number(1, Valtype.i32),
@@ -3758,6 +3775,8 @@ const generateForOf = (scope, decl) => {
     default: internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`)
   }, Blocktype.void));
 
+  out.push([ Opcodes.end ]); // end if
+
   depth.pop();
   depth.pop();
   depth.pop();
@@ -4334,55 +4353,55 @@ const generateArray = (scope, decl, global = false, name = '$undeclared', initEm
   return makeArray(scope, decl, global, name, initEmpty, valtype, false, true)[0];
 };
 
-const toPropertyKey = scope => Prefs.fastObject ? [] : [
-  [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__ecma262_ToPropertyKey').index) ]
+const toPropertyKey = (scope, i32Conv = false) => [
+  [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__ecma262_ToPropertyKey').index) ],
+  ...(i32Conv ? [
+    [ Opcodes.local_set, localTmp(scope, '#swap', Valtype.i32) ],
+    Opcodes.i32_to_u,
+    [ Opcodes.local_get, localTmp(scope, '#swap', Valtype.i32) ]
+  ] : [])
 ];
 
 const generateObject = (scope, decl, global = false, name = '$undeclared') => {
-  includeBuiltin(scope, 'Map');
-
-  // todo: optimize const objects
-  const tmp = localTmp(scope, `#objectexpr${randId()}`);
   const out = [
-    ...generateCall(scope, {
-      callee: {
-        type: 'Identifier',
-        name: 'Map'
-      },
-      arguments: [],
-      _new: true
-    }),
-    [ Opcodes.local_tee, tmp ]
+    [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Porffor_allocate').index) ]
   ];
 
-  for (const x of decl.properties) {
-    const { method, shorthand, computed, kind, key, value } = x;
-    if (kind !== 'init') return todo(scope, 'complex objects are not supported yet', true);
+  if (decl.properties.length > 0) {
+    const tmp = localTmp(scope, `#objectexpr${randId()}`, Valtype.i32);
+    out.push([ Opcodes.local_tee, tmp ]);
 
-    let k = key;
-    if (!computed && key.type !== 'Literal') k = {
-      type: 'Literal',
-      value: key.name
-    };
+    for (const x of decl.properties) {
+      const { method, shorthand, computed, kind, key, value } = x;
+      if (kind !== 'init') return todo(scope, 'complex objects are not supported yet', true);
 
-    out.push(
-      [ Opcodes.local_get, tmp ],
-      ...number(TYPES.map, Valtype.i32),
+      let k = key;
+      if (!computed && key.type !== 'Literal') k = {
+        type: 'Literal',
+        value: key.name
+      };
 
-      ...generate(scope, k),
-      ...getNodeType(scope, k),
-      ...toPropertyKey(scope),
+      out.push(
+        [ Opcodes.local_get, tmp ],
+        ...number(TYPES.object, Valtype.i32),
 
-      ...generate(scope, value),
-      ...getNodeType(scope, value),
+        ...generate(scope, k),
+        ...getNodeType(scope, k),
+        ...toPropertyKey(scope, true),
 
-      [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Map_prototype_set').index) ],
+        ...generate(scope, value),
+        ...getNodeType(scope, value),
 
-      [ Opcodes.drop ],
-      [ Opcodes.drop ]
-    );
+        [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Porffor_object_set').index) ],
+
+        [ Opcodes.drop ],
+        [ Opcodes.drop ]
+      );
+    }
   }
 
+  out.push(Opcodes.i32_from_u);
+
   return out;
 };
 
@@ -4603,13 +4622,14 @@ const generateMember = (scope, decl, _global, _name) => {
 
     [TYPES.object]: [
       ...objectWasm,
+      Opcodes.i32_to_u,
       ...getNodeType(scope, object),
 
       ...propertyWasm,
       ...getNodeType(scope, property),
-      ...toPropertyKey(scope),
+      ...toPropertyKey(scope, true),
 
-      [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Map_prototype_get').index) ],
+      [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Porffor_object_get').index) ],
       ...setLastType(scope)
     ],