porffor 0.20.10 → 0.21.0

package/compiler/codegen.js

@@ -74,91 +74,94 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
       return cacheAst(decl, generateCode(scope, decl));
 
     case 'ReturnStatement':
-      return cacheAst(decl, generateReturn(scope, decl))
+      return cacheAst(decl, generateReturn(scope, decl));
 
     case 'ExpressionStatement':
-      return cacheAst(decl, generateExp(scope, decl))
+      return cacheAst(decl, generateExp(scope, decl));
 
     case 'SequenceExpression':
-      return cacheAst(decl, generateSequence(scope, decl))
+      return cacheAst(decl, generateSequence(scope, decl));
 
     case 'ChainExpression':
-      return cacheAst(decl, generateChain(scope, decl))
+      return cacheAst(decl, generateChain(scope, decl));
 
     case 'CallExpression':
-      return cacheAst(decl, generateCall(scope, decl, global, name, valueUnused))
+      return cacheAst(decl, generateCall(scope, decl, global, name, valueUnused));
 
     case 'NewExpression':
-      return cacheAst(decl, generateNew(scope, decl, global, name))
+      return cacheAst(decl, generateNew(scope, decl, global, name));
 
     case 'Literal':
-      return cacheAst(decl, generateLiteral(scope, decl, global, name))
+      return cacheAst(decl, generateLiteral(scope, decl, global, name));
 
     case 'VariableDeclaration':
-      return cacheAst(decl, generateVar(scope, decl))
+      return cacheAst(decl, generateVar(scope, decl));
 
     case 'AssignmentExpression':
-      return cacheAst(decl, generateAssign(scope, decl))
+      return cacheAst(decl, generateAssign(scope, decl));
 
     case 'UnaryExpression':
-      return cacheAst(decl, generateUnary(scope, decl))
+      return cacheAst(decl, generateUnary(scope, decl));
 
     case 'UpdateExpression':
-      return cacheAst(decl, generateUpdate(scope, decl, global, name, valueUnused))
+      return cacheAst(decl, generateUpdate(scope, decl, global, name, valueUnused));
 
     case 'IfStatement':
-      return cacheAst(decl, generateIf(scope, decl))
+      return cacheAst(decl, generateIf(scope, decl));
 
     case 'ForStatement':
-      return cacheAst(decl, generateFor(scope, decl))
+      return cacheAst(decl, generateFor(scope, decl));
 
     case 'WhileStatement':
-      return cacheAst(decl, generateWhile(scope, decl))
+      return cacheAst(decl, generateWhile(scope, decl));
 
     case 'DoWhileStatement':
-      return cacheAst(decl, generateDoWhile(scope, decl))
+      return cacheAst(decl, generateDoWhile(scope, decl));
 
     case 'ForOfStatement':
-      return cacheAst(decl, generateForOf(scope, decl))
+      return cacheAst(decl, generateForOf(scope, decl));
+
+    case 'ForInStatement':
+      return cacheAst(decl, generateForIn(scope, decl));
 
     case 'SwitchStatement':
-      return cacheAst(decl, generateSwitch(scope, decl))
+      return cacheAst(decl, generateSwitch(scope, decl));
 
     case 'BreakStatement':
-      return cacheAst(decl, generateBreak(scope, decl))
+      return cacheAst(decl, generateBreak(scope, decl));
 
     case 'ContinueStatement':
-      return cacheAst(decl, generateContinue(scope, decl))
+      return cacheAst(decl, generateContinue(scope, decl));
 
     case 'LabeledStatement':
-      return cacheAst(decl, generateLabel(scope, decl))
+      return cacheAst(decl, generateLabel(scope, decl));
 
     case 'EmptyStatement':
-      return cacheAst(decl, generateEmpty(scope, decl))
+      return cacheAst(decl, generateEmpty(scope, decl));
 
     case 'MetaProperty':
-      return cacheAst(decl, generateMeta(scope, decl))
+      return cacheAst(decl, generateMeta(scope, decl));
 
     case 'ConditionalExpression':
-      return cacheAst(decl, generateConditional(scope, decl))
+      return cacheAst(decl, generateConditional(scope, decl));
 
     case 'ThrowStatement':
-      return cacheAst(decl, generateThrow(scope, decl))
+      return cacheAst(decl, generateThrow(scope, decl));
 
     case 'TryStatement':
-      return cacheAst(decl, generateTry(scope, decl))
+      return cacheAst(decl, generateTry(scope, decl));
 
     case 'DebuggerStatement':
-      return cacheAst(decl, [[ Opcodes.call, importedFuncs.debugger ]])
+      return cacheAst(decl, [[ Opcodes.call, importedFuncs.debugger ]]);
 
     case 'ArrayExpression':
-      return cacheAst(decl, generateArray(scope, decl, global, name))
+      return cacheAst(decl, generateArray(scope, decl, global, name));
 
     case 'ObjectExpression':
-      return cacheAst(decl, generateObject(scope, decl, global, name))
+      return cacheAst(decl, generateObject(scope, decl, global, name));
 
     case 'MemberExpression':
-      return cacheAst(decl, generateMember(scope, decl, global, name))
+      return cacheAst(decl, generateMember(scope, decl, global, name));
 
     case 'ExportNamedDeclaration':
       const funcsBefore = funcs.map(x => x.name);
@@ -173,7 +176,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
         }
       }
 
-      return cacheAst(decl, [])
+      return cacheAst(decl, []);
 
     case 'TaggedTemplateExpression': {
       const funcs = {
@@ -228,7 +231,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
       const func = decl.tag.name;
       // hack for inline asm
-      if (!funcs[func]) return cacheAst(decl, 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;
@@ -244,17 +247,17 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
         str += quasis[i + 1].value.raw;
       }
 
-      return cacheAst(decl, 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 cacheAst(decl, [])
+        return cacheAst(decl, []);
       }
 
-      return cacheAst(decl, todo(scope, `no generation for ${decl.type}!`))
+      return cacheAst(decl, todo(scope, `no generation for ${decl.type}!`));
   }
 };
 
@@ -3471,8 +3474,6 @@ const generateForOf = (scope, decl) => {
     generateVar(scope, { kind: 'var', _bare: true, declarations: [ { id: { name: leftName } } ] })
   }
 
-  // if (!leftName) console.log(decl.left?.declarations?.[0]?.id ?? decl.left);
-
   const [ local, isGlobal ] = lookupName(scope, leftName);
   if (!local) return todo(scope, 'for of failed to get left local (probably destructure)');
 
@@ -3784,6 +3785,120 @@ const generateForOf = (scope, decl) => {
   return out;
 };
 
+const generateForIn = (scope, decl) => {
+  const out = [];
+
+  // todo: for in inside for in might fuck up?
+  const pointer = localTmp(scope, '#forin_base_pointer', Valtype.i32);
+  const length = localTmp(scope, '#forin_length', Valtype.i32);
+  const counter = localTmp(scope, '#forin_counter', Valtype.i32);
+
+  out.push(
+    // set pointer as right
+    ...generate(scope, decl.right),
+    Opcodes.i32_to_u,
+    [ Opcodes.local_set, pointer ],
+
+    // set counter as 0 (could be already used)
+    ...number(0, Valtype.i32),
+    [ Opcodes.local_set, counter ],
+
+    // get length
+    [ Opcodes.local_get, pointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+    [ Opcodes.local_tee, length ],
+
+    [ Opcodes.if, Blocktype.void ]
+  );
+
+  depth.push('if');
+  depth.push('forin');
+  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 } } ] })
+  }
+
+  const [ local, isGlobal ] = lookupName(scope, leftName);
+  if (!local) return todo(scope, 'for of failed to get left local (probably destructure)');
+
+  // set type for local
+  // todo: optimize away counter and use end pointer
+  out.push(...typeSwitch(scope, getNodeType(scope, decl.right), {
+    [TYPES.object]: [
+      [ Opcodes.loop, Blocktype.void ],
+
+      [ Opcodes.local_get, pointer ],
+      [ Opcodes.i32_load, 0, 4 ],
+      [ Opcodes.local_tee, localTmp(scope, '#forin_tmp', Valtype.i32) ],
+
+      ...setType(scope, leftName, [
+        [ Opcodes.i32_const, 31 ],
+        [ Opcodes.i32_shr_u ],
+        [ Opcodes.if, Valtype.i32 ],
+          // unset MSB in tmp
+          [ Opcodes.local_get, localTmp(scope, '#forin_tmp', Valtype.i32) ],
+          ...number(0x7fffffff, Valtype.i32),
+          [ Opcodes.i32_and ],
+          [ Opcodes.local_set, localTmp(scope, '#forin_tmp', Valtype.i32) ],
+
+          [ Opcodes.i32_const, ...unsignedLEB128(TYPES.string) ],
+        [ Opcodes.else ],
+          [ Opcodes.i32_const, ...unsignedLEB128(TYPES.bytestring) ],
+        [ Opcodes.end ]
+      ]),
+
+      [ Opcodes.local_get, localTmp(scope, '#forin_tmp', Valtype.i32) ],
+      Opcodes.i32_from_u,
+      [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+
+      [ Opcodes.block, Blocktype.void ],
+      [ Opcodes.block, Blocktype.void ],
+      ...generate(scope, decl.body),
+      [ Opcodes.end ],
+
+      // increment iter pointer by 14
+      [ Opcodes.local_get, pointer ],
+      ...number(14, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_set, pointer ],
+
+      // increment counter by 1
+      [ Opcodes.local_get, counter ],
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_tee, counter ],
+
+      // loop if counter != length
+      [ Opcodes.local_get, length ],
+      [ Opcodes.i32_ne ],
+      [ Opcodes.br_if, 1 ],
+
+      [ Opcodes.end ],
+      [ Opcodes.end ]
+    ],
+
+    // todo: use Object.keys as fallback
+    default: internalThrow(scope, 'TypeError', `Tried for..in on unsupported type`)
+  }, Blocktype.void));
+
+  out.push([ Opcodes.end ]); // end if
+
+  depth.pop();
+  depth.pop();
+  depth.pop();
+
+  return out;
+};
+
 const generateSwitch = (scope, decl) => {
   const tmp = localTmp(scope, '#switch_disc');
   const out = [
@@ -3840,7 +3955,7 @@ const generateSwitch = (scope, decl) => {
 // find the nearest loop in depth map by type
 const getNearestLoop = () => {
   for (let i = depth.length - 1; i >= 0; i--) {
-    if (['while', 'dowhile', 'for', 'forof', 'switch'].includes(depth[i])) return i;
+    if (['while', 'dowhile', 'for', 'forof', 'forin', 'switch'].includes(depth[i])) return i;
   }
 
   return -1;
@@ -3859,6 +3974,7 @@ const generateBreak = (scope, decl) => {
     while: 2, // loop > if (wanted branch) (we are here)
     dowhile: 2, // loop > block (wanted branch) > block (we are here)
     forof: 2, // loop > block (wanted branch) > block (we are here)
+    forin: 2, // loop > block (wanted branch) > block (we are here)
     if: 1, // break inside if, branch 0 to skip the rest of the if
     switch: 1
   })[type];
@@ -3880,7 +3996,8 @@ const generateContinue = (scope, decl) => {
     for: 3, // loop (wanted branch) > if > block (we are here)
     while: 1, // loop (wanted branch) > if (we are here)
     dowhile: 3, // loop > block > block (wanted branch) (we are here)
-    forof: 3 // loop > block > block (wanted branch) (we are here)
+    forof: 3, // loop > block > block (wanted branch) (we are here)
+    forin: 3 // loop > block > block (wanted branch) (we are here)
   })[type];
 
   return [

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.20.10+137dc7300",
+  "version": "0.21.0+0c514ac58",
   "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.20.10+137dc7300';
+globalThis.version = '0.21.0+0c514ac58';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {