porffor 0.41.7 → 0.42.0

package/compiler/codegen.js

@@ -48,6 +48,7 @@ const cacheAst = (decl, wasm) => {
   return wasm;
 };
 
+let indirectFuncs = [];
 const funcRef = func => {
   func.generate?.();
 
@@ -55,35 +56,53 @@ const funcRef = func => {
     [ Opcodes.const, 'funcref', func.name ]
   ];
 
-  const wrapperArgc = Prefs.indirectWrapperArgc ?? 6;
-  if (func.returns.length === 2 && countParams(func) < wrapperArgc && !func.wrapperFunc) {
+  const wrapperArgc = Prefs.indirectWrapperArgc ?? 8;
+  if (!func.wrapperFunc) {
     const locals = {}, params = [];
-    for (let i = 0; i < wrapperArgc + (func.constr ? 2 : 0); i++) {
+    for (let i = 0; i < wrapperArgc + 2; i++) {
       params.push(valtypeBinary, Valtype.i32);
       locals[i * 2] = { idx: i * 2, type: valtypeBinary };
       locals[i * 2 + 1] = { idx: i * 2 + 1, type: Valtype.i32 };
     }
-    let localInd = (wrapperArgc + (func.constr ? 2 : 0)) * 2;
+    let localInd = (wrapperArgc + 2) * 2;
 
     const wasm = [];
+    const offset = func.constr ? 0 : 4;
     for (let i = 0; i < func.params.length; i++) {
-      wasm.push(
-        [ Opcodes.local_get, i ],
-        ...(i % 2 === 0 && func.params[i] === Valtype.i32 ? [ Opcodes.i32_to ]: [])
-      );
+      if (func.internal && func.name.includes('_prototype_') && i < 2) {
+        // special case: use real this for prototype internals
+        wasm.push(
+          [ Opcodes.local_get, 2 + i ],
+          ...(i % 2 === 0 && func.params[i] === Valtype.i32 ? [ Opcodes.i32_to ]: [])
+        );
+      } else {
+        wasm.push(
+          [ Opcodes.local_get, offset + (!func.internal || func.typedParams ? i : i * 2) ],
+          ...(i % 2 === 0 && func.params[i] === Valtype.i32 ? [ Opcodes.i32_to ]: [])
+        );
+      }
     }
 
     wasm.push([ Opcodes.call, func.index ]);
 
     if (func.returns[0] === Valtype.i32) {
-      const localIdx = localInd++;
-      locals[localIdx] = { idx: localIdx, type: Valtype.i32 };
+      if (func.returns.length === 2) {
+        const localIdx = localInd++;
+        locals[localIdx] = { idx: localIdx, type: Valtype.i32 };
 
-      wasm.push(
-        [ Opcodes.local_set, localIdx ],
-        Opcodes.i32_from,
-        [ Opcodes.local_get, localIdx ]
-      );
+        wasm.push(
+          [ Opcodes.local_set, localIdx ],
+          Opcodes.i32_from,
+          [ Opcodes.local_get, localIdx ]
+        );
+      } else {
+        wasm.push(Opcodes.i32_from);
+      }
+    }
+
+    if (func.returns.length === 1) {
+      // add built-in returnType if only returns a value
+      wasm.push(...number(func.returnType ?? TYPES.number, Valtype.i32));
     }
 
     const name = '#indirect_' + func.name;
@@ -93,16 +112,26 @@ const funcRef = func => {
       locals, localInd,
       returns: [ valtypeBinary, Valtype.i32 ],
       wasm,
-      constr: func.constr,
+      constr: true,
       internal: true,
-      index: currentFuncIndex++
+      indirect: true
     };
 
-    funcs.push(wrapperFunc);
-    funcIndex[name] = wrapperFunc.index;
+    indirectFuncs.push(wrapperFunc);
 
     wrapperFunc.jsLength = countLength(func);
     func.wrapperFunc = wrapperFunc;
+
+    if (!func.constr) {
+      // check not being constructed
+      wasm.unshift(
+        [ Opcodes.local_get, 0 ], // new.target value
+        Opcodes.i32_to_u,
+        [ Opcodes.if, Blocktype.void ], // if value is non-zero
+          ...internalThrow(wrapperFunc, 'TypeError', `${unhackName(func.name)} is not a constructor`), // throw type error
+        [ Opcodes.end ]
+      );
+    }
   }
 
   return [
@@ -2233,7 +2262,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       scope.table = true;
 
       let args = decl.arguments;
-      const wrapperArgc = Prefs.indirectWrapperArgc ?? 6;
+      const wrapperArgc = Prefs.indirectWrapperArgc ?? 8;
       if (args.length < wrapperArgc) {
         args = args.concat(new Array(wrapperArgc - args.length).fill(DEFAULT_VALUE()));
       }
@@ -2293,39 +2322,14 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
         ...typeSwitch(scope, getNodeType(scope, callee), {
           [TYPES.function]: () => [
-            // get if func we are calling is a constructor or not
+            ...forceDuoValtype(scope, newTargetWasm, Valtype.f64),
+            ...forceDuoValtype(scope, thisWasm, Valtype.f64),
+            ...out,
+
             [ Opcodes.local_get, calleeLocal ],
             Opcodes.i32_to_u,
-            ...number(48, Valtype.i32),
-            [ Opcodes.i32_mul ],
-            ...number(2, Valtype.i32),
-            [ Opcodes.i32_add ],
-            [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut')), 'read func lut' ],
-
-            ...number(0b10, Valtype.i32),
-            [ Opcodes.i32_and ],
-            [ Opcodes.if, Valtype.f64 ],
-              ...forceDuoValtype(scope, newTargetWasm, Valtype.f64),
-              ...forceDuoValtype(scope, thisWasm, Valtype.f64),
-              ...out,
-
-              [ Opcodes.local_get, calleeLocal ],
-              Opcodes.i32_to_u,
-              [ Opcodes.call_indirect, args.length + 2, 0 ],
-              ...setLastType(scope),
-            [ Opcodes.else ],
-              // throw if non-constructor called with new
-              ...(callAsNew ? [
-                ...internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, Valtype.f64)
-              ] : [
-                ...out,
-
-                [ Opcodes.local_get, calleeLocal ],
-                Opcodes.i32_to_u,
-                [ Opcodes.call_indirect, args.length, 0 ],
-                ...setLastType(scope)
-              ]),
-            [ Opcodes.end ]
+            [ Opcodes.call_indirect, args.length + 2, 0 ],
+            ...setLastType(scope)
           ],
 
           default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, Valtype.f64)
@@ -2362,16 +2366,12 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     paramOffset += 4;
   }
 
-  if (func && !func.hasRestArgument && args.length < paramCount) {
+  if (func && args.length < paramCount) {
     // too little args, push undefineds
-    args = args.concat(new Array(paramCount - args.length).fill(DEFAULT_VALUE()));
+    args = args.concat(new Array(paramCount - (func.hasRestArgument ? 1 : 0) - args.length).fill(DEFAULT_VALUE()));
   }
 
   if (func && func.hasRestArgument) {
-    if (args.length < paramCount) {
-      args = args.concat(new Array(paramCount - 1 - args.length).fill(DEFAULT_VALUE()));
-    }
-
     const restArgs = args.slice(paramCount - 1);
     args = args.slice(0, paramCount - 1);
     args.push({
@@ -2385,13 +2385,18 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     args = args.slice(0, paramCount);
   }
 
-  if (func && func.throws) scope.throws = true;
-
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (Array.isArray(arg)) {
       // if wasm, just append it
       out = out.concat(arg);
+
+      if (valtypeBinary !== Valtype.i32 &&
+        (func && func.params[paramOffset + i * (typedParams ? 2 : 1)] === Valtype.i32)
+      ) {
+        out.push(...forceDuoValtype(scope, [], Valtype.i32));
+      }
+
       continue;
     }
 
@@ -3662,8 +3667,11 @@ const generateUnary = (scope, decl) => {
     case 'delete': {
       if (decl.argument.type === 'MemberExpression') {
         const object = decl.argument.object;
-        const property = getProperty(decl.argument);
 
+        // disallow `delete super.*`
+        if (object.type === 'Super') return internalThrow(scope, 'ReferenceError', 'Cannot delete super property', true);
+
+        const property = getProperty(decl.argument);
         if (property.value === 'length' || property.value === 'name') scope.noFastFuncMembers = true;
 
         return [
@@ -4597,8 +4605,6 @@ const generateLabel = (scope, decl) => {
 };
 
 const generateThrow = (scope, decl) => {
-  scope.throws = true;
-
   let exceptionMode = Prefs.exceptionMode ?? 'stack';
   if (globalThis.precompile) exceptionMode = decl.argument.callee != null ? 'lut' : 'stack';
 
@@ -5056,11 +5062,7 @@ const toPropertyKey = (scope, wasm, type, computed = false, i32Conv = false) =>
   ...wasm,
   ...type,
   [ Opcodes.call, 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) ]
-  ] : [])
+  ...(i32Conv ? forceDuoValtype(scope, [], Valtype.i32) : [])
 ] : [
   ...wasm,
   ...(i32Conv ? [ Opcodes.i32_to_u ] : []),
@@ -5203,7 +5205,6 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
   if (decl.property.name === 'name' && hasFuncWithName(name) && !scope.noFastFuncMembers) {
     // eg: __String_prototype_toLowerCase -> toLowerCase
     if (name.startsWith('__')) name = name.split('_').pop();
-    if (name.startsWith('#indirect_')) name = name.slice(10);
     if (name.startsWith('#')) name = '';
 
     return withType(scope, makeString(scope, name, _global, _name, true), TYPES.bytestring);
@@ -5620,16 +5621,7 @@ const generateClass = (scope, decl) => {
     type: 'Identifier',
     name
   };
-  const proto = {
-    type: 'MemberExpression',
-    object: root,
-    property: {
-      type: 'Identifier',
-      name: 'prototype'
-    },
-    computed: false,
-    optional: false
-  };
+  const proto = getObjProp(root, 'prototype');
 
   const [ func, out ] = generateFunc(scope, {
     ...(body.find(x => x.kind === 'constructor')?.value ?? {
@@ -5656,7 +5648,7 @@ const generateClass = (scope, decl) => {
       // Bar.__proto__ = Foo
       // Bar.prototype.__proto__ = Foo.prototype
       ...generate(scope, setObjProp(root, '__proto__', decl.superClass)),
-      ...generate(scope, setObjProp(getObjProp(root, 'prototype'), '__proto__', getObjProp(decl.superClass, 'prototype')))
+      ...generate(scope, setObjProp(proto, '__proto__', getObjProp(decl.superClass, 'prototype')))
     );
   }
 
@@ -6339,7 +6331,7 @@ export default program => {
   };
   tags = [];
   exceptions = [];
-  funcs = [];
+  funcs = []; indirectFuncs = [];
   funcIndex = {};
   depth = [];
   pages = new Map();
@@ -6394,6 +6386,7 @@ export default program => {
   // todo: these should just be deleted once able
   for (let i = 0; i < funcs.length; i++) {
     const f = funcs[i];
+
     if (f.wasm) {
       // run callbacks
       const wasm = f.wasm;
@@ -6450,9 +6443,15 @@ export default program => {
   //   }
   // }
 
-  delete globals['#ind'];
+  // add indirect funcs to end of funcs
+  for (let i = 0; i < indirectFuncs.length; i++) {
+    const f = indirectFuncs[i];
+    f.index = currentFuncIndex++;
+  }
+
+  funcs.push(...indirectFuncs);
 
-  // console.log([...usedTypes].map(x => TYPE_NAMES[x]));
+  delete globals['#ind'];
 
   return { funcs, globals, tags, exceptions, pages, data };
 };

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.41.7+89be416c1",
+  "version": "0.42.0+93da2c806",
   "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.41.7+89be416c1';
+globalThis.version = '0.42.0+93da2c806';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {