porffor 0.28.2 → 0.28.4

package/compiler/codegen.js

@@ -2680,7 +2680,9 @@ const brTable = (input, bc, returns) => {
   return out;
 };
 
-const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
+let typeswitchDepth = 0;
+
+const typeSwitch = (scope, type, bc, returns = valtypeBinary, allowFallThrough = false) => {
   if (!Prefs.bytestring) delete bc[TYPES.bytestring];
 
   const known = knownType(scope, type);
@@ -2688,28 +2690,83 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
     return bc[known] ?? bc.default;
   }
 
-  if (Prefs.typeswitchBrtable)
+  if (Prefs.typeswitchBrtable) {
+    if (allowFallThrough) throw new Error(`Fallthrough is not currently supported with --typeswitch-brtable`)
     return brTable(type, bc, returns);
+  }
+
+  typeswitchDepth++;
+
+  let bcArr = bc;
+  // hack?: we do this so that typeswitchDepth can be properly handled
+  if (typeof bcArr === 'function') {
+    bcArr = bcArr();
+  }
+  // hack: we need to preserve insertion order for fall through so all objects are converted to entries
+  if (!Array.isArray(bcArr)) {
+    bcArr = Object.entries(bc);
+  } else {
+    bc = Object.fromEntries(bcArr);
+  }
 
-  const tmp = localTmp(scope, '#typeswitch_tmp' + (Prefs.typeswitchUniqueTmp ? uniqId() : ''), Valtype.i32);
+
+  const tmp = localTmp(scope, `#typeswitch_tmp${typeswitchDepth}${Prefs.typeswitchUniqueTmp ? uniqId() : ''}`, Valtype.i32);
   const out = [
     ...type,
     [ Opcodes.local_set, tmp ],
     [ Opcodes.block, returns ]
   ];
 
-  for (const x in bc) {
+  for (let i = 0; i < bcArr.length; i++) {
+    const x = bcArr[i][0];
     if (x === 'default') continue;
 
-    // if type == x
-    out.push([ Opcodes.local_get, tmp ]);
-    out.push(...number(x, Valtype.i32));
-    out.push([ Opcodes.i32_eq ]);
-
-    out.push([ Opcodes.if, Blocktype.void, `TYPESWITCH|${TYPE_NAMES[x]}` ]);
-    out.push(...bc[x]);
-    out.push([ Opcodes.br, 1 ]);
-    out.push([ Opcodes.end ]);
+    if (allowFallThrough) {
+      let types = [];
+      let wasm;
+      while (i < bcArr.length) {
+        if (bcArr[i][0] === 'default') continue;
+        types.push(bcArr[i][0]);
+        // look for an empty array, essentially acting as an additional type for our typecheck
+        const bodyWasm = bcArr[i][1];
+        if (bodyWasm.length != 0) {
+          wasm = bodyWasm;
+          break;
+        }
+        i++;
+      }
+      // if we found any types,
+      if (types.length > 0) {
+        for (let j = 0; j < types.length; j++) {
+          // create the type tests
+          out.push(
+            [ Opcodes.local_get, tmp ],
+            ...number(types[j], Valtype.i32),
+            [ Opcodes.i32_eq ]
+          );
+          // for every test but the first, or them together
+          if (j != 0) out.push([ Opcodes.i32_or ]);
+        }
+        out.push(
+          // create the consequent
+          [ Opcodes.if, Blocktype.void, `TYPESWITCH|${types.map(t => TYPE_NAMES[t]).join(',')}` ],
+            ...wasm,
+            // we don't need an `br 1` here because depth[-1] should be 'switch', and that's the only place this is used right now
+          [ Opcodes.end ]
+        );
+      }
+    } else {
+      // if type == x
+      out.push(
+        [ Opcodes.local_get, tmp ],
+        ...number(bcArr[i][0], Valtype.i32),
+        [ Opcodes.i32_eq ],
+        [ Opcodes.if, Blocktype.void, `TYPESWITCH|${TYPE_NAMES[x]}` ],
+          ...bcArr[i][1],
+          [ Opcodes.br, 1 ],
+        [ Opcodes.end ]
+      );
+    }
   }
 
   // default
@@ -2718,6 +2775,8 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
 
   out.push([ Opcodes.end, 'TYPESWITCH_end' ]);
 
+  typeswitchDepth--;
+
   return out;
 };
 
@@ -2846,6 +2905,7 @@ const generateVar = (scope, decl) => {
 
       let i = 0;
       const elements = [...x.id.elements];
+      // todo: if elements.length == 0 and Porffor.rawType(tmpName) is not iterable, throw a typeerror
       for (const e of elements) {
         switch (e?.type) {
           case 'RestElement': { // let [ ...foo ] = []
@@ -2878,20 +2938,6 @@ const generateVar = (scope, decl) => {
             continue; // skip i++
           }
 
-          case 'Identifier': { // let [ foo ] = []
-            decls.push({
-              type: 'VariableDeclarator',
-              id: e,
-              init: {
-                type: 'MemberExpression',
-                object: { type: 'Identifier', name: tmpName },
-                property: { type: 'Literal', value: i }
-              }
-            });
-
-            break;
-          }
-
           case 'AssignmentPattern': { // let [ foo = defaultValue ] = []
             decls.push({
               type: 'VariableDeclarator',
@@ -2902,7 +2948,8 @@ const generateVar = (scope, decl) => {
                 left: {
                   type: 'MemberExpression',
                   object: { type: 'Identifier', name: tmpName },
-                  property: { type: 'Literal', value: i }
+                  property: { type: 'Literal', value: i },
+                  computed: true
                 },
                 right: e.right
               }
@@ -2911,22 +2958,22 @@ const generateVar = (scope, decl) => {
             break;
           }
 
-          case 'ArrayPattern': { // let [ [ foo, bar ] ] = []
+          case 'ArrayPattern': // let [ [ foo, bar ] ] = []
+          case 'Identifier': // let [ foo ] = []
+          case 'ObjectPattern': { // let [ { foo } ] = []
             decls.push({
               type: 'VariableDeclarator',
               id: e,
               init: {
                 type: 'MemberExpression',
                 object: { type: 'Identifier', name: tmpName },
-                property: { type: 'Literal', value: i }
+                property: { type: 'Literal', value: i },
+                computed: true
               }
             });
 
             break;
           }
-
-          case 'ObjectPattern':
-            return todo(scope, 'object destructuring is not supported yet')
         }
 
         i++;
@@ -2952,8 +2999,69 @@ const generateVar = (scope, decl) => {
       continue;
     }
 
+    if (x.id.type === 'ObjectPattern') {
+      const decls = [];
+      const tmpName = '#destructure' + uniqId();
+
+      const properties = [...x.id.properties];
+      // todo: if properties.length == 0 and Porffor.rawType(tmpName) != object, throw a typeerror
+      for (const prop of properties) {
+        if (prop.type == 'Property') { // let { foo } = {}
+          if (prop.value.type === 'AssignmentPattern') { // let { foo = defaultValue } = {}
+            decls.push({
+              type: 'VariableDeclarator',
+              id: prop.value.left,
+              init: {
+                type: 'LogicalExpression',
+                operator: '??',
+                left: {
+                  type: 'MemberExpression',
+                  object: { type: 'Identifier', name: tmpName },
+                  property: prop.key,
+                  computed: prop.computed
+                },
+                right: prop.value.right
+              }
+            });
+          } else {
+            decls.push({
+              type: 'VariableDeclarator',
+              id: prop.value,
+              init: {
+                type: 'MemberExpression',
+                object: { type: 'Identifier', name: tmpName },
+                property: prop.key,
+                computed: prop.computed
+              }
+            });
+          }
+        } else { // let { ...foo } = {}
+          return todo(scope, 'object rest destructuring is not supported yet')
+        }
+      }
+
+      out = out.concat([
+        ...generateVar(scope, {
+          type: 'VariableDeclaration',
+          declarations: [{
+            type: 'VariableDeclarator',
+            id: { type: 'Identifier', name: tmpName },
+            init: x.init
+          }],
+          kind: decl.kind
+        }),
+        ...generateVar(scope, {
+          type: 'VariableDeclaration',
+          declarations: decls,
+          kind: decl.kind
+        })
+      ]);
+
+      continue;
+    }
+
     const name = mapName(x.id.name);
-    if (!name) return todo(scope, 'object destructuring is not supported yet')
+    if (!name) return todo(scope, `variable declarators of type ${x.id.type} are not supported yet`)
 
     if (x.init && isFuncType(x.init.type)) {
       // hack for let a = function () { ... }
@@ -3542,6 +3650,7 @@ const generateUpdate = (scope, decl, _global, _name, valueUnused = false) => {
 const generateIf = (scope, decl) => {
   const out = truthy(scope, generate(scope, decl.test), getNodeType(scope, decl.test), false, true);
 
+
   out.push([ Opcodes.if, Blocktype.void ]);
   depth.push('if');
 
@@ -4146,6 +4255,42 @@ const generateSwitch = (scope, decl) => {
 
   depth.push('switch');
 
+  if (
+    decl.discriminant.type === 'CallExpression' && decl.discriminant.callee.type === 'Identifier' && decl.discriminant.callee.name === '__Porffor_rawType'
+  ) {
+    const cases = []
+    let canTypeCheck = true;
+    for (const x of decl.cases) {
+      let type;
+      if (!x.test) {
+        type = 'default';
+      } else if (x.test.type === 'Literal') {
+        type = x.test.value;
+      } else if (x.test.type === 'Identifier' && x.test.name.startsWith('__Porffor_TYPES_')) {
+        type = TYPES[x.test.name.slice('__Porffor_TYPES_'.length)];
+      }
+      if (type !== undefined) {
+        cases.push([type, x.consequent]);
+      } else {
+        canTypeCheck = false;
+        break;
+      }
+    }
+
+    if (canTypeCheck) {
+      const ret = typeSwitch(scope, getNodeType(scope, decl.discriminant.arguments[0]), () => {
+        const ret = [];
+        for (const [type, consequent] of cases) {
+          const o = generateCode(scope, { body: consequent });
+          ret.push([type, o]);
+        }
+        return ret;
+      }, Blocktype.void, true);
+      depth.pop();
+      return ret;
+    }
+  }
+
   const cases = decl.cases.slice();
   const defaultCase = cases.findIndex(x => x.test == null);
   if (defaultCase != -1) {
@@ -4161,6 +4306,7 @@ const generateSwitch = (scope, decl) => {
   for (let i = 0; i < cases.length; i++) {
     const x = cases[i];
     if (x.test) {
+      // todo: this should use same value zero
       out.push(
         [ Opcodes.local_get, tmp ],
         ...generate(scope, x.test),
@@ -5596,6 +5742,7 @@ export default program => {
   pages = new Map();
   data = [];
   currentFuncIndex = importedFuncs.length;
+  typeswitchDepth = 0;
 
   const valtypeInd = ['i32', 'i64', 'f64'].indexOf(valtype);
 

package/compiler/opt.js

@@ -4,6 +4,37 @@ import { read_signedLEB128, read_ieee754_binary64 } from './encoding.js';
 import { log } from './log.js';
 import Prefs from './prefs.js';
 
+const hasType = (funcs, pages, type) => {
+  switch (type) {
+    case 'Array':
+      return pages.hasArray;
+    case 'String':
+      return pages.hasString;
+    case 'ByteString':
+      return pages.hasByteString;
+
+    case 'Map':
+    case 'Set':
+    case 'WeakMap':
+    case 'WeakSet':
+    case 'WeakRef':
+    case 'Date':
+    case 'Uint8Array':
+    case 'Int8Array':
+    case 'Uint8ClampedArray':
+    case 'Uint16Array':
+    case 'Int16Array':
+    case 'Uint32Array':
+    case 'Int32Array':
+    case 'Float32Array':
+    case 'Float64Array':
+      return funcs.some(x => x.name === type);
+
+    default:
+      return true;
+  }
+}
+
 export default (funcs, globals, pages, tags, exceptions) => {
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
   if (optLevel === 0) return;
@@ -176,13 +207,13 @@ export default (funcs, globals, pages, tags, exceptions) => {
         if (inst[0] === Opcodes.if && typeof inst[2] === 'string' && Prefs.rmUnusedTypes) {
           // remove unneeded typeswitch checks
 
-          const type = inst[2].split('|')[1];
-          let missing = false;
-          if (type === 'Array') missing = !pages.hasArray;
-          if (type === 'String') missing = !pages.hasString;
-          if (type === 'ByteString') missing = !pages.hasByteString;
-          if (['Set', 'Uint8Array', 'Int8Array', 'Uint8ClampedArray', 'Uint16Array', 'Int16Array', 'Uint32Array', 'Int32Array', 'Float32Array', 'Float64Array'].includes(type)) {
-            missing = funcs.find(x => x.name === type) == null;
+          const types = inst[2].split('|')[1].split(',');
+          let missing = true;
+          for (const type of types) {
+            if (hasType(funcs, pages, type)) {
+              missing = false;
+              break;
+            }
           }
 
           if (missing) {
@@ -196,11 +227,12 @@ export default (funcs, globals, pages, tags, exceptions) => {
               }
             }
 
-            wasm.splice(i - 3, 4 + j - i); // remove cond and this if
-            i -= 4;
+            const offset = 3 + 4 * (types.length - 1);
+            wasm.splice(i - offset, j - (i - offset) + 1); // remove cond and this if
+            i -= 1 + offset;
             inst = wasm[i];
 
-            if (Prefs.optLog) log('opt', `removed unneeded typeswitch check`);
+            if (Prefs.optLog) log('opt', `removed unneeded typeswitch check (${types})`);
           }
         }
 

package/compiler/precompile.js

@@ -121,7 +121,9 @@ const compile = async (file, _funcs) => {
           y.splice(1, 10, 'local', local.name, local.type);
         }
 
-        if (y[0] === Opcodes.const && (n[0] === Opcodes.local_set || n[0] === Opcodes.local_tee)) {
+        if (!n) continue;
+
+        if (y[0] === Opcodes.const &&(n[0] === Opcodes.local_set || n[0] === Opcodes.local_tee)) {
           const l = locals[n[1]];
           if (!l) continue;
           if (!['#member_prop'].includes(l.name) && ![TYPES.string, TYPES.array, TYPES.bytestring].includes(l.metadata?.type)) continue;

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.28.2+b2c217063",
+  "version": "0.28.4+0b6831c07",
   "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.28.2+b2c217063';
+globalThis.version = '0.28.4+0b6831c07';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {