porffor 0.42.3 → 0.42.5

package/compiler/assemble.js

@@ -121,20 +121,19 @@ export default (funcs, globals, tags, pages, data, noTreeshake = false) => {
 
   const nameSection = Prefs.d ? customSection('name', encodeNames(funcs)) : [];
 
-  const directFuncs = funcs.filter(x => !x.indirect);
+  const indirectFuncs = funcs.filter(x => x.indirect);
   const tableSection = !funcs.table ? [] : createSection(
     Section.table,
-    encodeVector([ [ Reftype.funcref, 0x00, ...unsignedLEB128(directFuncs.length) ] ])
+    encodeVector([ [ Reftype.funcref, 0x00, ...unsignedLEB128(indirectFuncs.length) ] ])
   );
   time('table section');
 
-  const emptyWrapperFunc = funcs.find(x => x.name === '#indirect#empty');
   const elementSection = !funcs.table ? [] : createSection(
     Section.element,
     encodeVector([ [
       0x00,
       Opcodes.i32_const, 0, Opcodes.end,
-      ...encodeVector(directFuncs.map(x => unsignedLEB128((x.wrapperFunc ?? emptyWrapperFunc ?? x).asmIndex)))
+      ...encodeVector(indirectFuncs.map(x => unsignedLEB128(x.asmIndex)))
     ] ])
   );
   time('element section');
@@ -147,8 +146,8 @@ export default (funcs, globals, tags, pages, data, noTreeshake = false) => {
 
     // generate func lut data
     const bytes = [];
-    for (let i = 0; i < directFuncs.length; i++) {
-      const func = directFuncs[i];
+    for (let i = 0; i < indirectFuncs.length; i++) {
+      const func = indirectFuncs[i].wrapperOf;
       let name = func.name;
 
       // userland exposed .length

package/compiler/builtins_objects.js

@@ -18,14 +18,14 @@ export default function({ builtinFuncs }, Prefs) {
       locals: [],
       returns: [ Valtype.i32 ],
       returnType: TYPES.object,
-      wasm: (scope, { allocPage, makeString, generate, getNodeType, builtin, glbl }) => {
+      wasm: (scope, { allocPage, makeString, generate, getNodeType, builtin, funcRef, glbl }) => {
         if (globalThis.precompile) return [ [ 'get object', name ] ];
 
         // todo/perf: precompute bytes here instead of calling real funcs if we really care about perf later
 
         let ptr;
         if (existingFunc) {
-          ptr = builtin(name, true);
+          ptr = funcRef(name)[0][1];
         } else {
           ptr = allocPage(scope, `builtin object: ${name}`);
         }
@@ -86,20 +86,11 @@ export default function({ builtinFuncs }, Prefs) {
       }
     };
 
-    if (existingFunc) {
-      this[name] = (scope, { builtin, funcRef }) => [
-        [ Opcodes.call, builtin('#get_' + name) ],
-        [ Opcodes.drop ],
-        ...funcRef(name)
-      ];
-      this[name].type = TYPES.function;
-    } else {
-      this[name] = (scope, { builtin }) => [
-        [ Opcodes.call, builtin('#get_' + name) ],
-        Opcodes.i32_from_u
-      ];
-      this[name].type = TYPES.object;
-    }
+    this[name] = (scope, { builtin }) => [
+      [ Opcodes.call, builtin('#get_' + name) ],
+      Opcodes.i32_from_u
+    ];
+    this[name].type = existingFunc ? TYPES.function : TYPES.object;
 
     for (const x in props) {
       const d = props[x];

package/compiler/codegen.js

@@ -79,7 +79,12 @@ const funcRef = func => {
         ],
         constr: true,
         internal: true,
-        indirect: true
+        indirect: true,
+        wrapperOf: {
+          name: '',
+          jsLength: 0
+        },
+        indirectIndex: indirectFuncs.length
       };
 
       // check not being constructed
@@ -91,6 +96,8 @@ const funcRef = func => {
         [ Opcodes.end ]
       );
 
+      // have empty func as indirect funcs 0 and 1
+      indirectFuncs.push(emptyFunc);
       indirectFuncs.push(emptyFunc);
     }
 
@@ -142,7 +149,9 @@ const funcRef = func => {
       wasm,
       constr: true,
       internal: true,
-      indirect: true
+      indirect: true,
+      wrapperOf: func,
+      indirectIndex: indirectFuncs.length
     };
 
     indirectFuncs.push(wrapperFunc);
@@ -163,7 +172,7 @@ const funcRef = func => {
   }
 
   return [
-    [ Opcodes.const, func.index - importedFuncs.length ]
+    [ Opcodes.const, func.wrapperFunc.indirectIndex ]
   ];
 };
 
@@ -429,7 +438,7 @@ const generateIdent = (scope, decl) => {
     ];
   };
 
-  return lookup(decl.name);
+  return lookup(decl.name, scope.identFailEarly);
 };
 
 const generateReturn = (scope, decl) => {
@@ -6022,20 +6031,8 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
     generate() {
       if (func.wasm) return func.wasm;
 
-      let errorWasm = null;
-      if (decl.generator) {
-        errorWasm = todo(func, 'generator functions are not supported');
-      }
-
-      if (errorWasm) {
-        return func.wasm = errorWasm.concat([
-          ...number(UNDEFINED),
-          ...number(TYPES.undefined, Valtype.i32)
-        ]);
-      }
-
       // generating, stub _wasm
-      func.wasm = [];
+      let wasm = func.wasm = [];
 
       let body = objectHack(decl.body);
       if (decl.type === 'ArrowFunctionExpression' && decl.expression) {
@@ -6046,24 +6043,72 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
         };
       }
 
-      for (const x in defaultValues) {
-        prelude.push(
-          ...getType(func, x),
+      func.identFailEarly = true;
+      let localInd = args.length * 2;
+      for (let i = 0; i < args.length; i++) {
+        const { name, def, destr, type } = args[i];
+
+        func.localInd = i * 2;
+        allocVar(func, name, false);
+
+        func.localInd = localInd;
+        if (type) {
+          const typeAnno = extractTypeAnnotation(type);
+          addVarMetadata(func, name, false, typeAnno);
+
+          // automatically add throws if unexpected this type to builtins
+          if (globalThis.precompile && i === 0 && func.name.includes('_prototype_') && [
+            TYPES.date, TYPES.number, TYPES.promise, TYPES.symbol,
+            TYPES.set, TYPES.map,
+            TYPES.weakref, TYPES.weakset, TYPES.weakmap,
+            TYPES.arraybuffer, TYPES.sharedarraybuffer, TYPES.dataview
+          ].includes(typeAnno.type)) {
+            let types = [ typeAnno.type ];
+            if (typeAnno.type === TYPES.number) types.push(TYPES.numberobject);
+            if (typeAnno.type === TYPES.string) types.push(TYPES.stringobject);
+
+            wasm.push(
+              ...typeIsNotOneOf([ [ Opcodes.local_get, func.locals[name].idx + 1 ] ], types),
+              [ Opcodes.if, Blocktype.void ],
+                ...internalThrow(func, 'TypeError', `${unhackName(func.name)} expects 'this' to be a ${TYPE_NAMES[typeAnno.type]}`),
+              [ Opcodes.end ]
+            );
+          }
+
+          // todo: if string, try converting to it to one
+        }
+
+        if (def) wasm.push(
+          ...getType(func, name),
           ...number(TYPES.undefined, Valtype.i32),
           [ Opcodes.i32_eq ],
           [ Opcodes.if, Blocktype.void ],
-            ...generate(func, defaultValues[x], false, x),
-            [ Opcodes.local_set, func.locals[x].idx ],
+            ...generate(func, def, false, name),
+            [ Opcodes.local_set, func.locals[name].idx ],
 
-            ...setType(func, x, getNodeType(func, defaultValues[x])),
+            ...setType(func, name, getNodeType(func, def)),
           [ Opcodes.end ]
         );
-      }
 
-      for (const x in destructuredArgs) {
-        prelude.push(
-          ...generateVarDstr(func, 'var', destructuredArgs[x], { type: 'Identifier', name: x }, undefined, false)
+        if (destr) wasm.push(
+          ...generateVarDstr(func, 'var', destr, { type: 'Identifier', name }, undefined, false)
         );
+
+        localInd = func.localInd;
+      }
+
+      func.identFailEarly = false;
+
+      if (globalThis.valtypeOverrides) {
+        if (globalThis.valtypeOverrides.returns[name]) func.returns = globalThis.valtypeOverrides.returns[name];
+        if (globalThis.valtypeOverrides.params[name]) {
+          func.params = globalThis.valtypeOverrides.params[name];
+
+          const localsVals = Object.values(func.locals);
+          for (let i = 0; i < func.params.length; i++) {
+            localsVals[i].type = func.params[i];
+          }
+        }
       }
 
       if (decl.async && !decl.generator) {
@@ -6074,7 +6119,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
         typeUsed(func, TYPES.promise);
       }
 
-      const wasm = prelude.concat(generate(func, body));
+      wasm = wasm.concat(generate(func, body));
 
       if (func.async) {
         // make promise at the start
@@ -6177,17 +6222,12 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
     }
   }
 
-  if (func.constr) {
-    allocVar(func, '#newtarget', false);
-    allocVar(func, '#this', false);
-  }
+  const args = [];
+  if (func.constr) args.push({ name: '#newtarget' }, { name: '#this' });
 
-  const prelude = [];
-  const defaultValues = {};
-  const destructuredArgs = {};
   let jsLength = 0;
   for (let i = 0; i < params.length; i++) {
-    let name;
+    let name, def, destr;
     const x = params[i];
     switch (x.type) {
       case 'Identifier': {
@@ -6197,13 +6237,12 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
       }
 
       case 'AssignmentPattern': {
+        def = x.right;
         if (x.left.name) {
           name = x.left.name;
-          defaultValues[name] = x.right;
         } else {
           name = '#arg_dstr' + i;
-          destructuredArgs[name] = x.left;
-          defaultValues[name] = x.right;
+          destr = x.left;
         }
 
         break;
@@ -6217,54 +6256,17 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
 
       default:
         name = '#arg_dstr' + i;
-        destructuredArgs[name] = x;
+        destr = x;
         jsLength++;
         break;
     }
 
-    allocVar(func, name, false);
-    if (typedInput && params[i].typeAnnotation) {
-      const typeAnno = extractTypeAnnotation(params[i]);
-      addVarMetadata(func, name, false, typeAnno);
-
-      // automatically add throws if unexpected this type to builtins
-      if (globalThis.precompile && i === 0 && func.name.includes('_prototype_') && [
-        TYPES.date, TYPES.number, TYPES.promise, TYPES.symbol,
-        TYPES.set, TYPES.map,
-        TYPES.weakref, TYPES.weakset, TYPES.weakmap,
-        TYPES.arraybuffer, TYPES.sharedarraybuffer, TYPES.dataview
-      ].includes(typeAnno.type)) {
-        let types = [ typeAnno.type ];
-        if (typeAnno.type === TYPES.number) types.push(TYPES.numberobject);
-        if (typeAnno.type === TYPES.string) types.push(TYPES.stringobject);
-
-        prelude.push(
-          ...typeIsNotOneOf([ [ Opcodes.local_get, func.locals[name].idx + 1 ] ], types),
-          [ Opcodes.if, Blocktype.void ],
-            ...internalThrow(func, 'TypeError', `${unhackName(func.name)} expects 'this' to be a ${TYPE_NAMES[typeAnno.type]}`),
-          [ Opcodes.end ]
-        );
-      }
-
-      // todo: if string, try converting to it to one
-    }
+    args.push({ name, def, destr, type: typedInput && params[i].typeAnnotation });
   }
 
-  func.params = Object.values(func.locals).map(x => x.type);
+  func.params = new Array((params.length + (func.constr ? 2 : 0)) * 2).fill(0).map((_, i) => i % 2 ? Valtype.i32 : valtypeBinary);
   func.jsLength = jsLength;
 
-  if (globalThis.valtypeOverrides) {
-    if (globalThis.valtypeOverrides.returns[name]) func.returns = globalThis.valtypeOverrides.returns[name];
-    if (globalThis.valtypeOverrides.params[name]) {
-      func.params = globalThis.valtypeOverrides.params[name];
-
-      const localsVals = Object.values(func.locals);
-      for (let i = 0; i < func.params.length; i++) {
-        localsVals[i].type = func.params[i];
-      }
-    }
-  }
-
   // force generate for main
   if (name === 'main') func.generate();
 

package/compiler/wrap.js

@@ -132,8 +132,7 @@ ${flags & 0b0001 ? `    get func idx: ${get}
       if (value < 0) {
         func = importedFuncs[value + importedFuncs.length];
       } else {
-        value += importedFuncs.length;
-        func = funcs.find(x => x.index === value);
+        func = funcs.find(x => x.wrapperFunc?.indirectIndex === value);
       }
 
       if (!func) return function () {};

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.42.3+c5814d029",
+  "version": "0.42.5+a3af054f9",
   "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.42.3+c5814d029';
+globalThis.version = '0.42.5+a3af054f9';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {