porffor 0.28.5 → 0.28.7

package/compiler/codegen.js

@@ -1848,12 +1848,33 @@ const createThisArg = (scope, decl, knownThis = undefined) => {
       ...number(TYPES.object, Valtype.i32)
     ];
   } else {
+    const name = mapName(decl.callee?.name);
+    if (name && name.startsWith('__') && name.includes('_prototype_')) {
+      // todo: this should just be same as decl._new
+      // but we do not support prototype, constructor, etc yet
+      // so do `this` as `new Type()` instead
+      const node = {
+        type: 'NewExpression',
+        callee: {
+          type: 'Identifier',
+          name: name.slice(2, name.indexOf('_', 2))
+        },
+        arguments: [],
+        _new: true
+      };
+
+      return [
+        ...generateCall(scope, node),
+        ...getNodeType(scope, node)
+      ];
+    }
+
     return [
       ...generate(scope, { type: 'Identifier', name: 'globalThis' }),
       ...getType(scope, 'globalThis')
     ];
   }
-}
+};
 
 const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   let name = mapName(decl.callee.name);
@@ -1955,6 +1976,52 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
   let out = [];
   if (protoName) {
+    if (protoName === 'call') {
+      const valTmp = localTmp(scope, '#call_val');
+      const typeTmp = localTmp(scope, '#call_type', Valtype.i32);
+
+      return generateCall(scope, {
+        type: 'CallExpression',
+        callee: target,
+        arguments: decl.arguments.slice(1),
+        _thisWasm: [
+          ...generate(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
+          [ Opcodes.local_tee, valTmp ],
+          ...getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
+          [ Opcodes.local_tee, typeTmp ],
+
+          // check not undefined or null
+          // todo: technically this should be allowed sometimes but for now, never
+          ...nullish(scope,
+            [ [ Opcodes.local_get, valTmp ] ],
+            [ [ Opcodes.local_get, typeTmp ] ],
+            false, true),
+          [ Opcodes.if, Blocktype.void ],
+          ...internalThrow(scope, 'TypeError', `Cannot use undefined or null as 'this'`),
+          [ Opcodes.end ],
+        ],
+        _thisWasmComponents: {
+          _callValue: [
+            ...generate(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
+            [ Opcodes.local_tee, valTmp ],
+            ...getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
+            [ Opcodes.local_set, typeTmp ],
+
+            // check not undefined or null
+            // todo: technically this should be allowed sometimes but for now, never
+            ...nullish(scope,
+              [ [ Opcodes.local_get, valTmp ] ],
+              [ [ Opcodes.local_get, typeTmp ] ],
+              false, true),
+            [ Opcodes.if, Blocktype.void ],
+              ...internalThrow(scope, 'TypeError', `Cannot use undefined or null as 'this'`),
+            [ Opcodes.end ],
+          ],
+          _callType: [ [ Opcodes.local_get, typeTmp ] ]
+        }
+      });
+    }
+
     if (['search'].includes(protoName)) {
       const regex = decl.arguments[0]?.regex?.pattern;
       if (!regex) return [
@@ -2003,6 +2070,15 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         [ Opcodes.local_set, localTmp(scope, '#proto_target#type', Valtype.i32) ],
       );
 
+      if (decl._thisWasm) {
+        // after to still generate original target
+        out.push(
+          ...decl._thisWasm,
+          [ Opcodes.local_set, localTmp(scope, '#proto_target#type', Valtype.i32) ],
+          [ Opcodes.local_set, localTmp(scope, '#proto_target') ]
+        );
+      }
+
       for (const x of builtinProtoCands) {
         const type = TYPES[x.split('_prototype_')[0].slice(2).toLowerCase()];
         if (type == null) continue;
@@ -2116,7 +2192,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       return [
         ...out,
 
-        ...typeSwitch(scope, builtinProtoCands.length > 0 ? [ [ Opcodes.local_get, localTmp(scope, '#proto_target#type', Valtype.i32) ] ] : getNodeType(scope, target), {
+        ...typeSwitch(scope, getNodeType(scope, target), {
           ...protoBC,
 
           // TODO: error better
@@ -2211,7 +2287,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       let locals = [];
 
       if (indirectMode === 'vararg') {
-        const minArgc = Prefs.indirectCallMinArgc ?? 3;
+        const minArgc = Prefs.indirectCallMinArgc ?? 5;
 
         if (args.length < minArgc) {
           args = args.concat(new Array(minArgc - args.length).fill(DEFAULT_VALUE()));
@@ -2221,14 +2297,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         out = out.concat(generate(scope, arg));
-
-        if (valtypeBinary !== Valtype.i32 && (
-          (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
-          (importedFuncs[name] && name.startsWith('profile'))
-        )) {
-          out.push(Opcodes.i32_to);
-        }
-
         out = out.concat(getNodeType(scope, arg));
 
         if (indirectMode === 'vararg') {
@@ -2389,7 +2457,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
             [ Opcodes.local_get, funcLocal ],
             ...number(128, Valtype.i32),
             [ Opcodes.i32_mul ],
-            ...number(2, Valtype.i32),
+            ...number(4, Valtype.i32),
             [ Opcodes.i32_add ],
             [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ],
             [ Opcodes.local_set, flags ],
@@ -2454,13 +2522,19 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
   }
 
+  let args = [...decl.arguments];
+  const internalProtoFunc = func && func.internal && func.name.includes('_prototype_');
+  if (!globalThis.precompile && internalProtoFunc && !decl._protoInternalCall) {
+    // just function called, not as prototype, add this to start
+    args.unshift(decl._thisWasmComponents ?? decl._thisWasm ?? createThisArg(scope, decl));
+  }
+
   if (func && func.constr) {
     out.push(...(decl._newTargetWasm ?? createNewTarget(scope, decl, idx - importedFuncs.length)));
     out.push(...(decl._thisWasm ?? createThisArg(scope, decl)));
     paramOffset += 4;
   }
 
-  let args = [...decl.arguments];
   if (func && !func.hasRestArgument && args.length < paramCount) {
     // too little args, push undefineds
     args = args.concat(new Array(paramCount - args.length).fill(DEFAULT_VALUE()));
@@ -2488,7 +2562,13 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    out = out.concat(generate(scope, arg));
+    if (Array.isArray(arg)) {
+      // if wasm, just append it
+      out = out.concat(arg);
+      continue;
+    }
+
+    out = out.concat(arg._callValue ?? generate(scope, arg));
 
     // todo: this should be used instead of the too many args thing above (by removing that)
     if (i >= paramCount) {
@@ -2509,7 +2589,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       out.push(Opcodes.i32_from);
     }
 
-    if (typedParams) out = out.concat(getNodeType(scope, arg));
+    if (typedParams) out = out.concat(arg._callType ?? getNodeType(scope, arg));
   }
 
   out.push([ Opcodes.call, idx ]);
@@ -2929,7 +3009,8 @@ const generateVar = (scope, decl) => {
                       object: { type: 'Identifier', name: tmpName, },
                       property: { type: 'Identifier', name: 'length', }
                     }
-                  ]
+                  ],
+                  _protoInternalCall: true
                 }
               });
             }
@@ -5009,13 +5090,23 @@ const countParams = (func, name = undefined) => {
   }
   if (func.argc) return func.argc;
 
+  name ??= func.name;
   let params = func.params.length;
   if (func.constr) params -= 4;
-  if (!func.internal || builtinFuncs[func.name]?.typedParams) params = Math.floor(params / 2);
+  if (!builtinFuncs[name] || builtinFuncs[name]?.typedParams) params = Math.floor(params / 2);
 
   return func.argc = params;
 };
 
+const countLength = (func, name = undefined) => {
+  name ??= func.name;
+
+  let count = countParams(func, name);
+  if (builtinFuncs[name] && name.includes('_prototype_')) count--;
+
+  return count;
+};
+
 const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) => {
   const name = decl.object.name;
 
@@ -5034,9 +5125,9 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
     // todo: support optional
 
     const func = funcs.find(x => x.name === name);
-    if (func) return withType(scope, number(countParams(func)), TYPES.number);
+    if (func) return withType(scope, number(countLength(func, name)), TYPES.number);
 
-    if (Object.hasOwn(builtinFuncs, name)) return withType(scope, number(countParams(builtinFuncs[name])), TYPES.number);
+    if (Object.hasOwn(builtinFuncs, name)) return withType(scope, number(countLength(builtinFuncs[name], name)), TYPES.number);
     if (Object.hasOwn(importedFuncs, name)) return withType(scope, number(importedFuncs[name].params.length ?? importedFuncs[name].params), TYPES.number);
     if (Object.hasOwn(internalConstrs, name)) return withType(scope, number(internalConstrs[name].length ?? 0), TYPES.number);
 
@@ -5368,7 +5459,7 @@ const objectHack = node => {
       if (node.computed || node.optional) return;
 
       // hack: block these properties as they can be accessed on functions
-      if (node.property.name == 'length' || node.property.name == 'name') return;
+      if (node.property.name == 'length' || node.property.name == 'name' || node.property.name == 'call') return;
 
       let objectName = node.object.name;
 
@@ -5447,6 +5538,7 @@ const generateFunc = (scope, decl) => {
     }
   }
 
+  const prelude = [];
   const defaultValues = {};
   for (let i = 0; i < params.length; i++) {
     let name;
@@ -5474,7 +5566,27 @@ const generateFunc = (scope, decl) => {
 
     allocVar(func, name, false);
     if (typedInput && params[i].typeAnnotation) {
-      addVarMetadata(func, name, false, extractTypeAnnotation(params[i]));
+      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)) {
+        prelude.push(
+          [ Opcodes.local_get, i * 2 + 1 ],
+          ...number(typeAnno.type, Valtype.i32),
+          [ Opcodes.i32_ne ],
+          [ 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
     }
   }
 
@@ -5489,7 +5601,6 @@ const generateFunc = (scope, decl) => {
     };
   }
 
-  const prelude = [];
   for (const x in defaultValues) {
     prelude.push(
       ...getType(func, x),
@@ -5539,7 +5650,7 @@ const generateFunc = (scope, decl) => {
 
     if (lastInst[0] === Opcodes.end || lastInst[0] === Opcodes.local_set || lastInst[0] === Opcodes.global_set) {
       if (lastInst[0] === Opcodes.local_set && lastInst[1] === func.locals['#last_type'].idx) {
-        func.wasm.splice(main.wasm.length - 1, 1);
+        func.wasm.splice(func.wasm.length - 1, 1);
       } else {
         func.returns = [];
       }

package/compiler/precompile.js

@@ -1,5 +1,5 @@
 import { Opcodes, Valtype } from './wasmSpec.js';
-import { read_unsignedLEB128 } from './encoding.js';
+import { read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
 import { TYPES } from './types.js';
 
 import process from 'node:process';
@@ -151,7 +151,7 @@ const compile = async (file, _funcs) => {
 
 
         if (y[0] === Opcodes.i32_const && n[0] === Opcodes.throw) {
-          const id = y[1];
+          const id = read_signedLEB128(y.slice(1));
           y.splice(0, 10, 'throw', exceptions[id].constructor, exceptions[id].message);
 
           // remove throw inst

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.5+4f843e06e",
+  "version": "0.28.7+a711fccd4",
   "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.5+4f843e06e';
+globalThis.version = '0.28.7+a711fccd4';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {