porffor 0.58.17 → 0.58.19

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) ];
   }
@@ -1520,16 +1519,9 @@ 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)) return globalInfer.get(name);
+    if (globalInfer.has(name) && inferLoopPrev.length === 0) return globalInfer.get(name);
   } else if (scope.inferTree) {
     for (let i = scope.inferTree.length - 1; i >= 0; i--) {
       const x = scope.inferTree[i];
@@ -1595,7 +1587,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) ];
   }
 
@@ -2294,9 +2286,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 +2305,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 +2329,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);
@@ -6717,7 +6627,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 +7204,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 +7243,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/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);
   }
@@ -119,18 +119,18 @@ const compile = async (file, _funcs) => {
           const f = funcs.find(x => x.index === idx);
           if (!f) {
             if (idx < importedFuncs.length) {
-              y.splice(1, 10, importedFuncs[idx].name);
+              wasm[i] = [ Opcodes.call, importedFuncs[idx].name ];
             }
 
             continue;
           }
 
-          y.splice(1, 10, f.name);
+          wasm[i] = [ Opcodes.call, f.name ];
         }
 
         if (y[0] === Opcodes.global_get || y[0] === Opcodes.global_set) {
           const global = invGlobals[y[1]];
-          y.splice(0, 10, 'global', y[0], global.name, global.type);
+          wasm[i] = [ 'global', y[0], global.name, global.type ];
 
           if (!x.globalInits) {
             if (!main.rewrittenGlobalInits) {
@@ -147,7 +147,7 @@ const compile = async (file, _funcs) => {
 
         if (rewriteLocals && typeof y[1] === 'number' && (y[0] === Opcodes.local_get || y[0] === Opcodes.local_set || y[0] === Opcodes.local_tee)) {
           const local = locals[y[1]];
-          y.splice(1, 10, 'local', local.name, local.type);
+          wasm[i] = [ y[0], 'local', local.name, local.type ];
         }
 
         if (!n) continue;
@@ -161,7 +161,7 @@ const compile = async (file, _funcs) => {
           if (!pageName || allocated.has(pageName)) return;
           allocated.add(pageName);
 
-          y.splice(0, 10, 'alloc', pageName, valtypeBinary);
+          wasm[i] = [ 'alloc', pageName, valtypeBinary ];
         };
 
         if (y[0] === Opcodes.const &&(n[0] === Opcodes.local_set || n[0] === Opcodes.local_tee)) {
@@ -177,7 +177,7 @@ const compile = async (file, _funcs) => {
           let id;
           if (y[0] === Opcodes.i32_const && n[1] === 0) {
             id = read_signedLEB128(y.slice(1));
-            y.splice(0, 10, 'throw', exceptions[id].constructor, exceptions[id].message);
+            wasm[i] = [ 'throw', exceptions[id].constructor, exceptions[id].message ];
 
             // remove throw inst
             wasm.splice(i + 1, 1);
@@ -249,7 +249,7 @@ ${funcs.map(x => {
       .replace(/\"local","(.*?)",(.*?)\]/g, (_, name, valtype) => `loc('${name}',${valtype})]`)
       .replace(/\[16,"(.*?)"]/g, (_, name) => `[16,builtin('${name}')]`)
       .replace(/\["funcref",(.*?),"(.*?)"]/g, (_1, op, name) => op === '65' ? `...i32ify(funcRef('${name}'))` : `...funcRef('${name}')`)
-      .replace(/\["str",(.*?),"(.*?)",(.*?)]/g, (_1, op, str, bytestring) => op === '65' ? `...i32ify(makeString(_,"${str}",${bytestring}))` : `...makeString(_,"${str}",${bytestring === 'true' ? 1 : 0})`)
+      .replace(/\["str",(.*?),"(.*?)",(.*?)]/g, (_1, op, str, bytestring) => op === '65' ? `...i32ify(makeString(_,"${str}",${bytestring === 'true' ? 1 : 0}))` : `...makeString(_,"${str}",${bytestring === 'true' ? 1 : 0})`)
       .replace(/\["throw","(.*?)","(.*?)"\]/g, (_, constructor, message) => `...internalThrow(_,'${constructor}',\`${message}\`)`)
       .replace(/\["get object","(.*?)"\]/g, (_, objName) => `...generateIdent(_,{name:'${objName}'})`)
       .replace(/\[null,"typeswitch case start",\[(.*?)\]\],/g, (_, types) => `...t([${types}],()=>[`)

package/fuzz/generator.js

@@ -8,9 +8,17 @@ const generators = {
     return `(${num})`;
   },
   string: () => {
-    const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-    const len = Math.floor(Math.random() * 8) + 1;
-    return `'${Array.from({length: len}, () => chars[Math.floor(Math.random() * chars.length)]).join('')}'`;
+    if (Math.random() < 0.1) {
+      return `''`;
+    }
+
+    const len = Math.floor(Math.random() * 32) + 1;
+    if (Math.random() < 0.8) { // bytestring
+      const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+      return `'${Array.from({length: len}, () => chars[Math.floor(Math.random() * chars.length)]).join('')}'`;
+    } else { // unicode string
+      return `'${Array.from({length: len}, () => `\\u${Math.floor(Math.random() * 0x10000).toString(16).padStart(4, '0')}`).join('')}'`;
+    }
   },
   boolean: () => Math.random() < 0.5 ? 'true' : 'false',
   null: () => 'null',
@@ -21,7 +29,7 @@ const generators = {
     if (depth > 2) return '[]';
     const len = Math.floor(Math.random() * 3);
     if (len === 0) return '[]';
-    const items = Array.from({length: len}, () => generateSimple());
+    const items = Array.from({ length: len }, () => generateExpression(depth + 1));
     return `[${items.join(', ')}]`;
   },
 
@@ -31,9 +39,12 @@ const generators = {
     const len = Math.floor(Math.random() * 3);
     if (len === 0) return '{}';
     const props = Array.from({length: len}, () => {
-      const key = String.fromCharCode(97 + Math.floor(Math.random() * 26));
-      // Ensure valid property syntax
-      return `'${key}': ${generateSimple()}`;
+      if (Math.random() < 0.5) {
+        const key = String.fromCharCode(97 + Math.floor(Math.random() * 26));
+        return `'${key}': ${generateExpression(depth + 1)}`;
+      } else {
+        return `[${generateExpression(depth + 1)}]: ${generateExpression(depth + 1)}`;
+      }
     });
     return `({${props.join(', ')}})`;
   },
@@ -63,27 +74,27 @@ function generateExpression(depth = 0) {
 
   const roll = Math.random();
 
-  if (roll < 0.4) {
+  if (roll < 0.3) {
     // Simple value
     return generateSimple();
-  } else if (roll < 0.6) {
+  } else if (roll < 0.4) {
     // Binary operation
     const ops = ['+', '-', '*', '/', '%', '===', '!==', '>', '<', '>=', '<=', '&&', '||'];
     const op = ops[Math.floor(Math.random() * ops.length)];
     return `(${generateExpression(depth + 1)} ${op} ${generateExpression(depth + 1)})`;
-  } else if (roll < 0.75) {
+  } else if (roll < 0.65) {
     // Unary operation
     const ops = ['!', '-', '+', 'typeof'];
     const op = ops[Math.floor(Math.random() * ops.length)];
     return `(${op} ${generateExpression(depth + 1)})`;
-  } else if (roll < 0.85) {
+  } else if (roll < 0.75) {
     // Function call
     const builtins = ['Math.abs', 'Math.floor', 'Math.ceil', 'String', 'Number', 'Boolean'];
     const func = builtins[Math.floor(Math.random() * builtins.length)];
     const argCount = Math.floor(Math.random() * 2);
     const args = Array.from({length: argCount}, () => generateExpression(depth + 1));
     return `${func}(${args.join(', ')})`;
-  } else if (roll < 0.95) {
+  } else if (roll < 0.85) {
     // Conditional
     return `(${generateExpression(depth + 1)} ? ${generateExpression(depth + 1)} : ${generateExpression(depth + 1)})`;
   } else {
@@ -105,10 +116,10 @@ function generateStatement(depth = 0, inFunction = false) {
   } else if (roll < 0.5 && declaredVars.length > 0) {
     // Variable assignment
     const varName = declaredVars[Math.floor(Math.random() * declaredVars.length)];
-    const ops = ['=', '+=', '-=', '*='];
+    const ops = ['=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '>>=', '>>>=', '<<='];
     const op = ops[Math.floor(Math.random() * ops.length)];
     return `${varName} ${op} ${generateExpression()};`;
-  } else if (roll < 0.65) {
+  } else if (roll < 0.6) {
     // If statement
     if (Math.random() < 0.5) {
       return `if (${generateExpression()}) { ${generateStatement(depth + 1, inFunction)} }`;
@@ -150,8 +161,7 @@ function generateFunction() {
     statements.push('  ' + generateStatement(0, true));
   }
 
-  // Always add a simple return to avoid syntax issues
-  statements.push('  return ' + generateSimple() + ';');
+  statements.push('  return ' + generateExpression() + ';');
 
   // Restore variables
   declaredVars = savedVars;
@@ -193,7 +203,7 @@ function generateProgram(options = {}) {
   }
 
   // Always end with a result
-  code += `var result = ${generateExpression()};\n`;
+  code += `var result = ${generateExpression()};`;
 
   return code;
 }

package/fuzz/index.js

@@ -17,8 +17,8 @@ if (cluster.isPrimary) {
   }
 
   const duration = parseFloat(process.argv.find(x => x.startsWith('--duration='))?.split('=')?.[1]) || 60; // seconds
-  const maxStatements = parseInt(process.argv.find(x => x.startsWith('--max-statements='))?.split('=')?.[1]) || 8;
-  const maxFunctions = parseInt(process.argv.find(x => x.startsWith('--max-functions='))?.split('=')?.[1]) || 2;
+  const maxStatements = parseInt(process.argv.find(x => x.startsWith('--max-statements='))?.split('=')?.[1]) || 20;
+  const maxFunctions = parseInt(process.argv.find(x => x.startsWith('--max-functions='))?.split('=')?.[1]) || 4;
   const verbose = process.argv.includes('--verbose');
   const saveFailures = process.argv.includes('--save-failures');
   const plainResults = process.argv.includes('--plain-results');
@@ -141,7 +141,17 @@ if (cluster.isPrimary) {
         const error = `${msg.error.name}: ${msg.error.message}`
           .replace(/\([0-9]+:[0-9]+\)/, '')
           .replace(/@\+[0-9]+/, '');
-        errorCounts.set(error, (errorCounts.get(error) || 0) + 1);
+
+        const count = errorCounts.get(error) || 0;
+        errorCounts.set(error, count + 1);
+
+        if (count === 0) {
+          const resultNames = ['PASS', 'TODO', 'WASM_ERROR', 'COMPILE_ERROR', 'FAIL', 'TIMEOUT', 'RUNTIME_ERROR'];
+          console.log('\n---');
+          console.log(`\x1b[4mNEW ${resultNames[result]}: ${error}\x1b[0m`);
+          console.log(msg.code);
+          console.log('---\n');
+        }
       }
 
       if (result === 0) {
@@ -262,7 +272,8 @@ if (cluster.isPrimary) {
     process.send({
       result,
       error: error ? { name: error.name, message: error.message } : null,
-      code: verbose || saveFailures ? code : null
+      // code: verbose || saveFailures ? code : null
+      code
     });
   });
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.58.17",
+  "version": "0.58.19",
   "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.17';
+globalThis.version = '0.58.19';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {

package/wow.js

@@ -0,0 +1 @@
+(false ? 42 : 42) + (false ? null : 'G9vBsCA4GzkqlZN')