porffor 0.58.18 → 0.59.0

package/compiler/codegen.js

@@ -2,7 +2,6 @@ import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
 import { number, ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector, read_signedLEB128 } from './encoding.js';
 import { operatorOpcode } from './expression.js';
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
-import { PrototypeFuncs } from './prototype.js';
 import { TYPES, TYPE_FLAGS, TYPE_NAMES } from './types.js';
 import parse from './parse.js';
 import { log } from './log.js';
@@ -556,7 +555,7 @@ const lookup = (scope, name, failEarly = false) => {
     includeBuiltin(scope, name);
   }
 
-  if (isExistingProtoFunc(name) || Object.hasOwn(internalConstrs, name)) {
+  if (Object.hasOwn(internalConstrs, name)) {
     // todo: return an actual something
     return [ number(1) ];
   }
@@ -1506,6 +1505,7 @@ const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTy
     typeUsed(func, returnType);
   }
 
+  func.jsLength = countLength(func);
   func.wasm = wasm;
   return func;
 };
@@ -1520,13 +1520,6 @@ const includeBuiltin = (scope, builtin) => {
 const generateLogicExp = (scope, decl) =>
   performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right));
 
-const isExistingProtoFunc = name => {
-  if (name.startsWith('__Array_prototype')) return Object.hasOwn(prototypeFuncs[TYPES.array], name.slice(18));
-  if (name.startsWith('__String_prototype_')) return Object.hasOwn(prototypeFuncs[TYPES.string], name.slice(19));
-
-  return false;
-};
-
 const getInferred = (scope, name, global = false) => {
   if (global) {
     if (globalInfer.has(name) && inferLoopPrev.length === 0) return globalInfer.get(name);
@@ -1595,7 +1588,7 @@ const getType = (scope, name, failEarly = false) => {
     [ global ? Opcodes.global_get : Opcodes.local_get, typeLocal.idx ]
   ];
 
-  if (hasFuncWithName(name) || isExistingProtoFunc(name)) {
+  if (hasFuncWithName(name)) {
     return [ number(TYPES.function, Valtype.i32) ];
   }
 
@@ -1830,6 +1823,12 @@ const getNodeType = (scope, node) => {
         case '__Porffor_bs': return TYPES.bytestring;
         case '__Porffor_s': return TYPES.string;
       }
+
+      return getNodeType(scope, {
+        type: 'CallExpression',
+        callee: node.tag,
+        arguments: []
+      });
     }
 
     if (node.type === 'ThisExpression') {
@@ -2294,9 +2293,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       });
     }
 
-    const protoBC = {};
     const builtinProtoCands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + protoName));
-
     if (!decl._protoInternalCall && builtinProtoCands.length > 0) {
       out.push(
         ...generate(scope, target),
@@ -2315,6 +2312,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         );
       }
 
+      const protoBC = {};
       for (const x of builtinProtoCands) {
         const name = x.split('_prototype_')[0].toLowerCase();
         const type = TYPES[name.slice(2)] ?? TYPES[name];
@@ -2338,88 +2336,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           _protoInternalCall: true
         });
       }
-    }
-
-    const protoCands = Object.keys(prototypeFuncs).reduce((acc, x) => {
-      if (Object.hasOwn(prototypeFuncs[x], protoName)) acc[x] = prototypeFuncs[x][protoName];
-      return acc;
-    }, {});
-
-    if (Object.keys(protoCands).length > 0) {
-      // use local for cached i32 length as commonly used
-      const lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
-      const pointerLocal = localTmp(scope, '__proto_pointer_cache', Valtype.i32);
-
-      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 ]
-        );
-      }
-
-      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),
-            ...setLastType(scope, TYPES.number)
-          ];
-          continue;
-        }
-
-        protoBC[x] = () => {
-          const protoLocal = protoFunc.local ? localTmp(scope, `__${protoName}_tmp`, protoFunc.local) : -1;
-          const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${protoName}_tmp2`, protoFunc.local2) : -1;
-
-          let optUnused = false;
-          const protoOut = protoFunc({
-            pointer: getPointer,
-            length: {
-              getCachedI32: () => [ [ Opcodes.local_get, lengthLocal ] ],
-              setCachedI32: () => [ [ Opcodes.local_set, lengthLocal ] ],
-              get: () => ArrayUtil.getLength(getPointer),
-              getI32: () => ArrayUtil.getLengthI32(getPointer),
-              set: value => ArrayUtil.setLength(getPointer, value),
-              setI32: value => ArrayUtil.setLengthI32(getPointer, value)
-            },
-            arg: generate(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
-            argType: getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
-            iTmp: protoLocal,
-            iTmp2: protoLocal2,
-            alloc: bytes => [
-              number(bytes, Valtype.i32),
-              [ Opcodes.call, includeBuiltin(scope, '__Porffor_allocateBytes').index ]
-            ],
-            unusedValue: () => {
-              optUnused = true;
-              return unusedValue;
-            },
-            setType: type => setLastType(scope, type)
-          });
-
-          return [
-            ...ArrayUtil.getLengthI32(getPointer),
-            [ Opcodes.local_set, lengthLocal ],
-
-            [ Opcodes.block, unusedValue && optUnused ? Blocktype.void : valtypeBinary ],
-              ...protoOut,
-            [ Opcodes.end ],
-            ...(unusedValue && optUnused ? [ number(UNDEFINED) ] : [])
-          ];
-        };
-      }
-    }
 
-    if (Object.keys(protoBC).length > 0) {
       protoBC.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`, true);
@@ -5850,7 +5767,24 @@ const countLength = (func, name = undefined) => {
 
   let count = countParams(func, name);
   if (builtinFuncs[name] && name.includes('_prototype_')) count--;
-
+  if (func.hasRestArgument) count--;
+
+  if (func.internal) {
+    // some js built-ins have an old non-standard length
+    const override = ({
+      Array: 1,
+      String: 1,
+      __Object_assign: 2,
+      __String_fromCharCode: 1,
+      __String_fromCodePoint: 1,
+      __Array_prototype_concat: 1,
+      __Array_prototype_push: 1,
+      __Array_prototype_unshift: 1,
+      __String_prototype_concat: 1,
+      __ByteString_prototype_concat: 1
+    })[name];
+    if (override != null) return override;
+  }
   return count;
 };
 
@@ -6671,20 +6605,41 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
     return cacheAst(decl, intrinsics[decl.tag.name](str));
   }
 
-  return generate(scope, {
-    type: 'CallExpression',
-    callee: decl.tag,
-    arguments: [
-      { // strings
-        type: 'ArrayExpression',
-        elements: quasis.map(x => ({
-          type: 'Literal',
-          value: x.value.cooked
-        }))
-      },
-      ...expressions
-    ]
-  });
+  const tmp = localTmp(scope, '#tagged_template_strings');
+  const tmpIdent = {
+    type: 'Identifier',
+    name: '#tagged_template_strings',
+    _type: TYPES.array
+  };
+
+  return [
+    ...generate(scope, {
+      type: 'ArrayExpression',
+      elements: quasis.map(x => ({
+        type: 'Literal',
+        value: x.value.cooked
+      }))
+    }),
+    [ Opcodes.local_set, tmp ],
+
+    ...generate(scope, setObjProp(tmpIdent, 'raw', {
+      type: 'ArrayExpression',
+      elements: quasis.map(x => ({
+        type: 'Literal',
+        value: x.value.raw
+      }))
+    })),
+    [ Opcodes.drop ],
+
+    ...generate(scope, {
+      type: 'CallExpression',
+      callee: decl.tag,
+      arguments: [
+        tmpIdent,
+        ...expressions
+      ]
+    })
+  ];
 };
 
 globalThis._uniqId = 0;
@@ -6717,7 +6672,7 @@ const objectHack = node => {
       if (objectName !== 'Object_prototype' && (node.property.name === 'propertyIsEnumerable' || node.property.name === 'hasOwnProperty' || node.property.name === 'isPrototypeOf')) return abortOut;
 
       const name = '__' + objectName + '_' + node.property.name;
-      if ((!hasFuncWithName(name) && !Object.hasOwn(builtinVars, name) && !isExistingProtoFunc(name) && !hasFuncWithName(name + '$get')) && (hasFuncWithName(objectName) || Object.hasOwn(builtinVars, objectName) || hasFuncWithName('__' + objectName) || Object.hasOwn(builtinVars, '__' + objectName))) return abortOut;
+      if ((!hasFuncWithName(name) && !Object.hasOwn(builtinVars, name) && !hasFuncWithName(name + '$get')) && (hasFuncWithName(objectName) || Object.hasOwn(builtinVars, objectName) || hasFuncWithName('__' + objectName) || Object.hasOwn(builtinVars, '__' + objectName))) return abortOut;
 
       if (Prefs.codeLog) log('codegen', `object hack! ${node.object.name}.${node.property.name} -> ${name}`);
 
@@ -7294,7 +7249,7 @@ const internalConstrs = {
   }
 };
 
-let globals, tags, exceptions, funcs, indirectFuncs, funcIndex, currentFuncIndex, depth, pages, data, typeswitchDepth, usedTypes, coctc, globalInfer, builtinFuncs, builtinVars, prototypeFuncs, lastValtype;
+let globals, tags, exceptions, funcs, indirectFuncs, funcIndex, currentFuncIndex, depth, pages, data, typeswitchDepth, usedTypes, coctc, globalInfer, builtinFuncs, builtinVars, lastValtype;
 export default program => {
   globals = { ['#ind']: 0 };
   tags = [];
@@ -7333,7 +7288,6 @@ export default program => {
     lastValtype = valtypeBinary;
     builtinFuncs = new BuiltinFuncs();
     builtinVars = new BuiltinVars({ builtinFuncs });
-    prototypeFuncs = new PrototypeFuncs();
 
     const getObjectName = x => x.startsWith('__') && x.slice(2, x.indexOf('_', 2));
     objectHackers = ['assert', 'compareArray', 'Test262Error', ...new Set(Object.keys(builtinFuncs).map(getObjectName).concat(Object.keys(builtinVars).map(getObjectName)).filter(x => x))];

package/compiler/pgo.js

@@ -1,20 +1,26 @@
 import { Opcodes, Valtype } from './wasmSpec.js';
 import { number } from './encoding.js';
-import { createImport, importedFuncs } from './builtins.js';
+import { createImport, importedFuncs, setImports } from './builtins.js';
 import assemble from './assemble.js';
 import wrap from './wrap.js';
 import * as Havoc from './havoc.js';
 import './prefs.js';
+import fs from 'node:fs';
 
+let activeFunc, localData;
 export const setup = () => {
   // enable these prefs by default for pgo
   for (const x of [
     'typeswitchUniqueTmp', // use unique tmps for typeswitches
-    'lengthNoTmp', // use duplicated inline code instead of tmp for .length
-    'cyclone', // enable cyclone pre-evaler
+    // 'cyclone', // enable cyclone pre-evaler
   ]) {
     Prefs[x] = Prefs[x] === false ? false : true;
   }
+
+  createImport('profileLocalSet', [ Valtype.i32, Valtype.i32, Valtype.f64 ], 0, (activeFunc, i, n) => {
+    if (activeFunc == null) throw 'fail';
+    localData[activeFunc][i].push(n);
+  });
 };
 
 export const run = obj => {
@@ -34,15 +40,7 @@ export const run = obj => {
 
   time(0, `injecting PGO logging...`);
 
-  let activeFunc = null, abort = false;
-  createImport('profile1', [ Valtype.i32 ], 0, n => {
-    activeFunc = n;
-  });
-  createImport('profile2', [ Valtype.i32, Valtype.f64 ], 0, (i, n) => {
-    if (activeFunc == null) throw 'fail';
-    localData[activeFunc][i].push(n);
-  });
-
+  let abort = false;
   let funcs = [];
   for (let i = 0; i < wasmFuncs.length; i++) {
     const { name, internal, params, locals, wasm } = wasmFuncs[i];
@@ -55,16 +53,13 @@ export const run = obj => {
     funcs.push({ name, id, locals, params, invLocals });
 
     wasm.unshift(
-      // mark active func
-      number(i, Valtype.i32),
-      [ Opcodes.call, importedFuncs.profile1 ],
-
       // log args
       ...params.flatMap((_, i) => [
+        number(id, Valtype.i32),
         number(i, Valtype.i32),
         [ Opcodes.local_get, i ],
         ...(invLocals[i].type !== Valtype.f64 ? [ Opcodes.i32_from ] : []),
-        [ Opcodes.call, importedFuncs.profile2 ]
+        [ Opcodes.call, importedFuncs.profileLocalSet ]
       ])
     );
 
@@ -72,49 +67,32 @@ export const run = obj => {
       const inst = wasm[j];
       if (inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) {
         wasm.splice(j + 1, 0,
+          number(id, Valtype.i32),
           number(inst[1], Valtype.i32),
           [ Opcodes.local_get, inst[1] ],
           ...(invLocals[inst[1]].type !== Valtype.f64 ? [ Opcodes.i32_from ] : []),
-          [ Opcodes.call, importedFuncs.profile2 ]
+          [ Opcodes.call, importedFuncs.profileLocalSet ]
         );
       }
     }
   }
 
-  let localData = funcs.map(x => new Array(Object.keys(x.locals).length).fill(0).map(() => []));
+  localData = funcs.map(x => new Array(Object.keys(x.locals).length).fill(0).map(() => []));
 
   time(0, `injected PGO logging`);
   time(1, `running with PGO logging...`);
 
-
   try {
     obj.wasm = assemble(obj.funcs, obj.globals, obj.tags, obj.pages, obj.data, true);
 
     Prefs._profileCompiler = Prefs.profileCompiler;
     Prefs.profileCompiler = false;
 
-    const { exports } = wrap(obj, undefined, {
-      readArgv: (ind, outPtr) => {
-        // const pgoInd = process.argv.indexOf('--pgo');
-        // let args = process.argv.slice(pgoInd);
-        // args = args.slice(args.findIndex(x => !x.startsWith('-')) + 1);
-
-        // const str = args[ind - 1];
-        // if (pgoInd === -1 || !str) {
-        //   if (Prefs.pgoLog) console.log('\nPGO warning: script was expecting arguments, please specify args to use for PGO after --pgo arg');
-        //   return -1;
-        // }
-
-        // writeByteStr(exports.$, outPtr, str);
-        // return str.length;
-        return -1;
-      },
-      readFile: (pathPtr, outPtr) => {
-        return -1;
-      }
-    }, () => {});
-
+    const priorImports = { ...importedFuncs };
+    const { exports } = wrap(obj, undefined, () => {});
     exports.main();
+
+    setImports(priorImports);
   } catch (e) {
     throw e;
   }
@@ -242,8 +220,8 @@ export const run = obj => {
       consts.push(number(c, valtype));
     }
 
-    log += `  ${x.name}: replaced ${targets.length} locals with consts\n`;
-    if (targets.length > 0) Havoc.localsToConsts(wasmFunc, targets, consts, { localKeys: x.localKeys });
+    // log += `  ${x.name}: replaced ${targets.length} locals with consts\n`;
+    // if (targets.length > 0) Havoc.localsToConsts(wasmFunc, targets, consts, { localKeys: x.localKeys });
   }
 
   time(3, 'optimized using PGO data\n' + log);

package/compiler/precompile.js

@@ -57,7 +57,7 @@ const compile = async (file, _funcs) => {
     first = source.slice(0, source.indexOf('\n'));
   }
 
-  let args = ['--module', '--todo-time=compile', '--truthy=no_nan_negative', '--no-rm-unused-types', '--scoped-page-names', '--funsafe-no-unlikely-proto-checks', '--zero-checks=charCodeAt', '--fast-length', '--parse-types', '--opt-types', '--no-passive-data', '--active-data', '--no-treeshake-wasm-imports', '--no-coctc'];
+  let args = ['--module', '--todo-time=compile', '--truthy=no_nan_negative', '--no-rm-unused-types', '--scoped-page-names', '--fast-length', '--parse-types', '--opt-types', '--no-passive-data', '--active-data', '--no-treeshake-wasm-imports', '--no-coctc'];
   if (first.startsWith('// @porf')) {
     args = first.slice('// @porf '.length).split(' ').concat(args);
   }

package/compiler/wrap.js

@@ -481,10 +481,9 @@ export { createImport };
  *
  * @param {string} source - JavaScript source code to compile
  * @param {boolean} module - If the source is a module or not (default: false)
- * @param {object} customImports - Custom imports
  * @param {(str: string) => void} print - Function to use for printing (used by console.log etc)
  */
-export default (source, module = undefined, customImports = {}, print = str => process.stdout.write(str)) => {
+export default (source, module = undefined, print = str => process.stdout.write(str)) => {
   createImport('print', 1, 0, i => print(i.toString()));
   createImport('printChar', 1, 0, i => print(String.fromCharCode(i)));
   createImport('time', 0, 1, () => performance.now());
@@ -512,12 +511,6 @@ export default (source, module = undefined, customImports = {}, print = str => p
     }
   });
 
-  for (const x in customImports) {
-    const custom = customImports[x];
-    // todo: make a simpler api for just js functions at some point using function.length etc
-    createImport(x, custom.params, custom.returns, custom.js, custom.c);
-  }
-
   const times = [];
 
   const t1 = performance.now();
@@ -575,6 +568,8 @@ export default (source, module = undefined, customImports = {}, print = str => p
     instance = new WebAssembly.Instance(module, {
       '': Object.keys(importedFuncs).reduce((acc, y) => {
         const x = importedFuncs[y];
+        if (!x.import) return acc;
+
         acc[x.import] = x.js ?? (() => {});
         return acc;
       }, {})

package/fuzz/index.js

@@ -246,7 +246,7 @@ if (cluster.isPrimary) {
     let stage = 0;
 
     try {
-      const out = compile(code, false, {});
+      const out = compile(code, false);
 
       try {
         out.exports.main();

package/package.json

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

package/runtime/debug.js

@@ -109,7 +109,7 @@ createImport('profile2', 1, 0, n => {
 });
 
 try {
-  const { exports } = compile(source, undefined, {}, s => output += s);
+  const { exports } = compile(source, undefined, s => output += s);
   exports.main();
 } catch (e) {
   console.error(e);

package/runtime/index.js

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

package/runtime/profile.js

@@ -94,7 +94,7 @@ globalThis.compileCallback = ({ funcs }) => {
 };
 
 console.log('Compiling...');
-const { exports } = compile(source, undefined, {}, () => {});
+const { exports } = compile(source, undefined, () => {});
 
 // --- Execution with Progress Spinner ---
 

package/runtime/repl.js

@@ -95,7 +95,7 @@ const run = (source, _context, _filename, callback, run = true) => {
 
   let shouldPrint = !prev;
   try {
-    const { exports, pages } = compile(toRun, undefined, {}, str => {
+    const { exports, pages } = compile(toRun, undefined, str => {
       if (shouldPrint) process.stdout.write(str);
       if (str === '-4919') shouldPrint = true;
     });