porffor 0.58.4 → 0.58.6

package/compiler/codegen.js

@@ -45,17 +45,23 @@ const funcRef = func => {
 
   const wrapperArgc = Prefs.indirectWrapperArgc ?? 10;
   if (!func.wrapperFunc) {
-    const locals = {}, params = [];
+    const locals = {
+      ['#length']: { idx: 0, type: Valtype.i32 }
+    }, params = [
+      Valtype.i32
+    ];
+
     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 };
+      locals[`#${i}`] = { idx: 1 + i * 2, type: valtypeBinary };
+      locals[`#${i}#type`] = { idx: 2 + i * 2, type: Valtype.i32 };
     }
-    let localInd = (wrapperArgc + 2) * 2;
+    let localInd = 1 + (wrapperArgc + 2) * 2;
 
     if (indirectFuncs.length === 0) {
       // add empty indirect func
       const emptyFunc = {
+        constr: true, internal: true, indirect: true,
         name: '#indirect#empty',
         params,
         locals: { ...locals }, localInd,
@@ -64,9 +70,6 @@ const funcRef = func => {
           number(0),
           number(0, Valtype.i32)
         ],
-        constr: true,
-        internal: true,
-        indirect: true,
         wrapperOf: {
           name: '',
           jsLength: 0
@@ -76,7 +79,7 @@ const funcRef = func => {
 
       // check not being constructed
       emptyFunc.wasm.unshift(
-        [ Opcodes.local_get, 0 ], // new.target value
+        [ Opcodes.local_get, 1 ], // new.target value
         Opcodes.i32_to_u,
         [ Opcodes.if, Blocktype.void ], // if value is non-zero
           ...internalThrow(emptyFunc, 'TypeError', `Function is not a constructor`), // throw type error
@@ -88,27 +91,94 @@ const funcRef = func => {
     }
 
     const wasm = [];
-    const offset = func.constr ? 0 : (func.method ? 2 : 4);
-    for (let i = 0; i < func.params.length; i++) {
-      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 {
+    const name = '#indirect_' + func.name;
+    const wrapperFunc = {
+      constr: true, internal: true, indirect: true,
+      name, params, locals, localInd,
+      returns: [ valtypeBinary, Valtype.i32 ],
+      wasm,
+      wrapperOf: func,
+      indirectIndex: indirectFuncs.length
+    };
+
+    indirectFuncs.push(wrapperFunc);
+
+    wrapperFunc.jsLength = countLength(func);
+    func.wrapperFunc = wrapperFunc;
+
+    const paramCount = countParams(func, name);
+    const args = [];
+    for (let i = 0; i < paramCount - (func.hasRestArgument ? 1 : 0); i++) {
+      args.push({
+        type: 'Identifier',
+        name: `#${i + 2}`
+      });
+    }
+
+    if (func.hasRestArgument) {
+      const array = (wrapperFunc.localInd += 2) - 2;
+      locals['#array#i32'] = { idx: array, type: Valtype.i32 };
+      locals['#array'] = { idx: array + 1, type: valtypeBinary };
+
+      wasm.push(
+        [ Opcodes.call, includeBuiltin(wrapperFunc, '__Porffor_allocate').index ],
+        [ Opcodes.local_tee, array ],
+        Opcodes.i32_from_u,
+        [ Opcodes.local_set, array + 1 ],
+
+        [ Opcodes.local_get, array ],
+        [ Opcodes.local_get, 0 ],
+        number(paramCount - 1, Valtype.i32),
+        [ Opcodes.i32_sub ],
+        [ Opcodes.i32_store, 0, 0 ]
+      );
+
+      let offset = 4;
+      for (let i = paramCount - 1; i < wrapperArgc; i++) {
         wasm.push(
-          [ Opcodes.local_get, offset + (!func.internal || func.typedParams ? i : i * 2) ],
-          ...(i % 2 === 0 && func.params[i] === Valtype.i32 ? [ Opcodes.i32_to ]: [])
+          [ Opcodes.local_get, array ],
+          [ Opcodes.local_get, 5 + i * 2 ],
+          [ Opcodes.f64_store, 0, offset ],
+
+          [ Opcodes.local_get, array ],
+          [ Opcodes.local_get, 6 + i * 2 ],
+          [ Opcodes.i32_store8, 0, offset + 8 ],
         );
+        offset += 9;
       }
+
+      args.push({
+        type: 'SpreadElement',
+        argument: {
+          type: 'Identifier',
+          name: '#array',
+          _type: TYPES.array
+        }
+      });
     }
 
-    wasm.push([ Opcodes.call, func.index ]);
+    wasm.push(...generate(wrapperFunc, {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: func.name
+      },
+      _funcIdx: func.index,
+      arguments: args,
+      _insideIndirect: true,
+      _newTargetWasm: [
+        [ Opcodes.local_get, 1 ],
+        [ Opcodes.local_get, 2 ]
+      ],
+      _thisWasm: [
+        [ Opcodes.local_get, 3 ],
+        [ Opcodes.local_get, 4 ]
+      ]
+    }));
 
     if (func.returns[0] === Valtype.i32) {
       if (func.returns.length === 2) {
-        const localIdx = localInd++;
+        const localIdx = wrapperFunc.localInd++;
         locals[localIdx] = { idx: localIdx, type: Valtype.i32 };
 
         wasm.push(
@@ -131,29 +201,10 @@ const funcRef = func => {
       wasm.push(number(func.returnType ?? TYPES.number, Valtype.i32));
     }
 
-    const name = '#indirect_' + func.name;
-    const wrapperFunc = {
-      name,
-      params,
-      locals, localInd,
-      returns: [ valtypeBinary, Valtype.i32 ],
-      wasm,
-      constr: true,
-      internal: true,
-      indirect: true,
-      wrapperOf: func,
-      indirectIndex: indirectFuncs.length
-    };
-
-    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.local_get, 1 ], // 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
@@ -2053,7 +2104,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     name = func.name;
   }
 
-  if (!decl._new && (name === 'eval' || (decl.callee.type === 'SequenceExpression' && decl.callee.expressions.at(-1)?.name === 'eval'))) {
+  if (!decl._funcIdx && !decl._new && (name === 'eval' || (decl.callee.type === 'SequenceExpression' && decl.callee.expressions.at(-1)?.name === 'eval'))) {
     const known = knownValue(scope, decl.arguments[0]);
     if (known !== unknownValue) {
       // eval('with known/literal string')
@@ -2099,7 +2150,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     }
   }
 
-  if (name === 'Function') {
+  if (!decl._funcIdx && name === 'Function') {
     const knowns = decl.arguments.map(x => knownValue(scope, x));
     if (knowns.every(x => x !== unknownValue)) {
       // new Function('with known/literal strings')
@@ -2235,19 +2286,24 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       const lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
       const pointerLocal = localTmp(scope, '__proto_pointer_cache', Valtype.i32);
 
-      // TODO: long-term, prototypes should be their individual separate funcs
-
-      const rawPointer = [
-        ...generate(scope, target),
-        Opcodes.i32_to_u
-      ];
-
-      const usePointerCache = !Object.values(protoCands).every(x => x.noPointerCache === true);
-      const getPointer = usePointerCache ? [ [ Opcodes.local_get, pointerLocal ] ] : rawPointer;
+      if (out.length === 0) {
+        out.push(
+          ...generate(scope, target),
+          Opcodes.i32_to_u,
+          [ Opcodes.local_set, pointerLocal ]
+        );
+      } else {
+        out.push(
+          [ Opcodes.local_get, localTmp(scope, '#proto_target') ],
+          Opcodes.i32_to_u,
+          [ Opcodes.local_set, pointerLocal ]
+        );
+      }
 
-      const useLengthCache = true; // basically every prototype uses it
       for (const x in protoCands) {
         const protoFunc = protoCands[x];
+        const getPointer = [ [ Opcodes.local_get, pointerLocal ] ];
+
         if (protoFunc.noArgRetLength && decl.arguments.length === 0) {
           protoBC[x] = [
             ...ArrayUtil.getLength(getPointer),
@@ -2287,37 +2343,16 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           });
 
           return [
-            [ Opcodes.block, unusedValue ? Blocktype.void : valtypeBinary ],
+            ...ArrayUtil.getLengthI32(getPointer),
+            [ Opcodes.local_set, lengthLocal ],
+
+            [ Opcodes.block, unusedValue && optUnused ? Blocktype.void : valtypeBinary ],
               ...protoOut,
-              ...(unusedValue && !optUnused ? [ [ Opcodes.drop ] ] : []),
-            [ Opcodes.end ]
+            [ Opcodes.end ],
+            ...(unusedValue && optUnused ? [ number(UNDEFINED) ] : [])
           ];
         };
       }
-
-      // alias primitive prototype with primitive object types
-      aliasPrimObjsBC(protoBC);
-
-      return [
-        ...(usePointerCache ? [
-          ...rawPointer,
-          [ Opcodes.local_set, pointerLocal ],
-        ] : []),
-
-        ...(useLengthCache ? [
-          ...ArrayUtil.getLengthI32(getPointer),
-          [ Opcodes.local_set, lengthLocal ],
-        ] : []),
-
-        ...typeSwitch(scope, getNodeType(scope, target), {
-          ...protoBC,
-
-          // TODO: error better
-          default: decl.optional ? withType(scope, [ number(UNDEFINED) ], TYPES.undefined)
-            : internalThrow(scope, 'TypeError', `'${protoName}' proto func tried to be called on a type without an impl`, !unusedValue)
-        }, unusedValue ? Blocktype.void : valtypeBinary),
-        ...(unusedValue ? [ number(UNDEFINED) ] : [])
-      ];
     }
 
     if (Object.keys(protoBC).length > 0) {
@@ -2372,7 +2407,9 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   let idx;
-  if (Object.hasOwn(funcIndex, name)) {
+  if (decl._funcIdx) {
+    idx = decl._funcIdx;
+  } else if (Object.hasOwn(funcIndex, name)) {
     idx = funcIndex[name];
   } else if (scope.name === name) {
     // fallback for own func but with a different var/id name
@@ -2501,7 +2538,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       }
     }
 
-    let callee = decl.callee, callAsNew = decl._new;
+    let callee = decl.callee, callAsNew = decl._new, sup = false;
     if (callee.type === 'Super') {
       // call super constructor with direct super() call
       callee = getObjProp(callee, 'constructor');
@@ -2510,6 +2547,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         ...generate(scope, { type: 'ThisExpression' }),
         ...getNodeType(scope, { type: 'ThisExpression' })
       ];
+      sup = true;
     }
 
     const newTargetWasm = decl._newTargetWasm ?? createNewTarget(scope, decl, [
@@ -2517,32 +2555,35 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     ], callAsNew);
     const thisWasm = decl._thisWasm ?? knownThis ?? createThisArg(scope, decl);
 
-    return [
+    out = [
       ...(getCallee ? getCallee : generate(scope, callee)),
       [ Opcodes.local_set, calleeLocal ],
 
       ...typeSwitch(scope, getNodeType(scope, callee), {
         [TYPES.function]: () => [
+          number(10 - underflow, Valtype.i32),
           ...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 ],
+          [ Opcodes.call_indirect, args.length + 2, 0,  ],
           ...setLastType(scope)
         ],
 
         default: decl.optional ? withType(scope, [ number(UNDEFINED, Valtype.f64) ], TYPES.undefined)
           : internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, Valtype.f64)
-      }, Valtype.f64),
-      ...(valtypeBinary === Valtype.i32 ? [ Opcodes.i32_trunc_sat_f64_s ] : [])
+      }, Valtype.f64)
     ];
+
+    if (valtypeBinary === Valtype.i32) out.push(Opcodes.i32_trunc_sat_f64_s);
+    if (sup) out.push([ null, 'super marker' ]);
+    return out;
   }
 
   const func = funcByIndex(idx);
-
-  if (func && !decl._new) func.onlyNew = false;
+  if (func && !decl._new && !decl._insideIndirect) func.onlyNew = false;
 
   // generate func
   if (func) func.generate?.();
@@ -2638,6 +2679,8 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   out.push([ Opcodes.call, idx ]);
+  if (decl._insideIndirect) return out;
+
   if (typedReturns) out.push(...setLastType(scope));
 
   if (
@@ -6205,14 +6248,33 @@ const generateClass = (scope, decl) => {
   const proto = getObjProp(root, 'prototype');
 
   const [ func, out ] = generateFunc(scope, {
-    ...(body.find(x => x.kind === 'constructor')?.value ?? {
+    ...(body.find(x => x.kind === 'constructor')?.value ?? (decl.superClass ? {
+      type: 'FunctionExpression',
+      params: [
+        {
+          type: 'RestElement',
+          argument: { type: 'Identifier', name: 'args' }
+        }
+      ],
+      body: {
+        type: 'ExpressionStatement',
+        expression: {
+          type: 'CallExpression',
+          callee: { type: 'Super' },
+          arguments: [ {
+            type: 'SpreadElement',
+            argument: { type: 'Identifier', name: 'args' }
+          } ]
+        }
+      }
+    }: {
       type: 'FunctionExpression',
       params: [],
       body: {
         type: 'BlockStatement',
         body: []
       }
-    }),
+    })),
     id: root,
     strict: true,
     type: expr ? 'FunctionExpression' : 'FunctionDeclaration',
@@ -6223,6 +6285,13 @@ const generateClass = (scope, decl) => {
   // always generate class constructor funcs
   func.generate();
 
+  let constrInsertIndex = func.wasm.findIndex(x => x.at(-1) === 'super marker');
+  if (constrInsertIndex != -1) {
+    func.wasm.splice(constrInsertIndex, 1);
+  } else {
+    constrInsertIndex = 0;
+  }
+
   if (decl.superClass) {
     const superTmp = localTmp(scope, '#superclass');
     const superTypeTmp = localTmp(scope, '#superclass#type', Valtype.i32);
@@ -6285,6 +6354,7 @@ const generateClass = (scope, decl) => {
   scope.overrideThis = generate(scope, root);
   scope.overrideThisType = TYPES.function;
 
+  let constrAdd = [];
   for (const x of body) {
     let { type, value, kind, static: _static, computed } = x;
     if (kind === 'constructor') continue;
@@ -6349,7 +6419,7 @@ const generateClass = (scope, decl) => {
         );
       }
 
-      func.wasm.unshift(
+      const constrWasm = [
         ...generate(func, object),
         Opcodes.i32_to_u,
         ...getNodeType(func, object),
@@ -6368,7 +6438,10 @@ const generateClass = (scope, decl) => {
         ...getNodeType(func, value),
 
         [ Opcodes.call, includeBuiltin(func, `__Porffor_object_class_${initKind}`).index ]
-      );
+      ];
+
+      func.wasm.splice(constrInsertIndex, 0, ...constrWasm);
+      constrInsertIndex += constrWasm.length;
     } else {
       out.push(
         ...generate(scope, object),

package/compiler/prototype.js

@@ -320,7 +320,6 @@ export const PrototypeFuncs = function() {
   this[TYPES.string].at.local2 = Valtype.i32;
   this[TYPES.string].charAt.local = Valtype.i32;
   this[TYPES.string].charCodeAt.local = Valtype.i32;
-  this[TYPES.string].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
   this[TYPES.bytestring] = {
     at: ({ pointer, length, arg, iTmp, iTmp2, alloc, setType }) => [
@@ -454,5 +453,4 @@ export const PrototypeFuncs = function() {
   this[TYPES.bytestring].at.local2 = Valtype.i32;
   this[TYPES.bytestring].charAt.local = Valtype.i32;
   this[TYPES.bytestring].charCodeAt.local = Valtype.i32;
-  this[TYPES.bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 };

package/foo.js

@@ -0,0 +1,5 @@
+let bcPtr = 16;
+let classNegate = false;
+if (true) {
+  Porffor.wasm.i32.store8(bcPtr, classNegate ? 0x03 : 0x02, 0, 0);
+}

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@honk/porffor",
-  "version": "0.58.4",
+  "version": "0.58.6",
   "exports": "./compiler/wrap.js",
   "publish": {
     "exclude": [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.58.4",
+  "version": "0.58.6",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/runtime/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.58.4';
+globalThis.version = '0.58.6';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {