porffor 0.58.15 → 0.58.16

package/compiler/codegen.js

@@ -4583,6 +4583,7 @@ const generateConditional = (scope, decl) => {
   );
 
   out.push([ Opcodes.end ]);
+  depth.pop();
   inferBranchEnd(scope);
 
   return out;

package/fuzz/generator.js

@@ -0,0 +1,201 @@
+// Track declared variables to avoid undefined references
+let declaredVars = [];
+
+const generators = {
+  // Literals - wrap in parens to avoid identifier issues like 9.prototype
+  number: () => {
+    const num = Math.random() < 0.5 ? Math.floor(Math.random() * 100) : Math.random() * 100;
+    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('')}'`;
+  },
+  boolean: () => Math.random() < 0.5 ? 'true' : 'false',
+  null: () => 'null',
+  undefined: () => 'undefined',
+
+  // Arrays - simple arrays only
+  array: (depth = 0) => {
+    if (depth > 2) return '[]';
+    const len = Math.floor(Math.random() * 3);
+    if (len === 0) return '[]';
+    const items = Array.from({length: len}, () => generateSimple());
+    return `[${items.join(', ')}]`;
+  },
+
+  // Objects - simple objects only
+  object: (depth = 0) => {
+    if (depth > 2) return '{}';
+    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()}`;
+    });
+    return `({${props.join(', ')}})`;
+  },
+
+  // Variables - only use declared ones
+  variable: () => {
+    if (declaredVars.length === 0) return '42';
+    return declaredVars[Math.floor(Math.random() * declaredVars.length)];
+  }
+};
+
+// Generate simple expressions (no complex nesting)
+function generateSimple() {
+  const simpleTypes = ['number', 'string', 'boolean', 'null', 'undefined'];
+  if (declaredVars.length > 0 && Math.random() < 0.3) {
+    simpleTypes.push('variable');
+  }
+  const type = simpleTypes[Math.floor(Math.random() * simpleTypes.length)];
+  const result = generators[type]();
+  // Ensure we never return undefined/null that could cause syntax issues
+  return result || '42';
+}
+
+// Generate expressions with controlled complexity
+function generateExpression(depth = 0) {
+  if (depth > 2) return generateSimple();
+
+  const roll = Math.random();
+
+  if (roll < 0.4) {
+    // Simple value
+    return generateSimple();
+  } else if (roll < 0.6) {
+    // 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) {
+    // Unary operation
+    const ops = ['!', '-', '+', 'typeof'];
+    const op = ops[Math.floor(Math.random() * ops.length)];
+    return `(${op} ${generateExpression(depth + 1)})`;
+  } else if (roll < 0.85) {
+    // 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) {
+    // Conditional
+    return `(${generateExpression(depth + 1)} ? ${generateExpression(depth + 1)} : ${generateExpression(depth + 1)})`;
+  } else {
+    // Array or object
+    return Math.random() < 0.5 ? generators.array(depth) : generators.object(depth);
+  }
+}
+
+function generateStatement(depth = 0, inFunction = false) {
+  if (depth > 2) return `${generateSimple()};`;
+
+  const roll = Math.random();
+
+  if (roll < 0.3) {
+    // Variable declaration
+    const varName = `var${declaredVars.length}`;
+    declaredVars.push(varName);
+    return `var ${varName} = ${generateExpression()};`;
+  } else if (roll < 0.5 && declaredVars.length > 0) {
+    // Variable assignment
+    const varName = declaredVars[Math.floor(Math.random() * declaredVars.length)];
+    const ops = ['=', '+=', '-=', '*='];
+    const op = ops[Math.floor(Math.random() * ops.length)];
+    return `${varName} ${op} ${generateExpression()};`;
+  } else if (roll < 0.65) {
+    // If statement
+    if (Math.random() < 0.5) {
+      return `if (${generateExpression()}) { ${generateStatement(depth + 1, inFunction)} }`;
+    } else {
+      return `if (${generateExpression()}) { ${generateStatement(depth + 1, inFunction)} } else { ${generateStatement(depth + 1, inFunction)} }`;
+    }
+  } else if (roll < 0.75) {
+    // Loop
+    if (Math.random() < 0.5) {
+      const limit = Math.floor(Math.random() * 5) + 1;
+      return `for (let i = 0; i < ${limit}; i++) { ${generateStatement(depth + 1, inFunction)} }`;
+    } else {
+      return `while (${generateExpression(depth + 1)}) { ${generateStatement(depth + 1, inFunction)} break; }`;
+    }
+  } else if (roll < 0.85) {
+    // Try/catch
+    return `try { ${generateStatement(depth + 1, inFunction)} } catch (e) { ${generateStatement(depth + 1, inFunction)} }`;
+  } else if (roll < 0.95 && inFunction) {
+    // Return (only in functions)
+    return `return ${generateExpression()};`;
+  } else {
+    // Expression statement
+    return `${generateExpression()};`;
+  }
+}
+
+function generateFunction() {
+  const name = `func${Math.floor(Math.random() * 100)}`;
+  const paramCount = Math.floor(Math.random() * 3);
+  const params = Array.from({length: paramCount}, (_, i) => `param${i}`);
+
+  // Save current variables and add parameters
+  const savedVars = [...declaredVars];
+  params.forEach(p => declaredVars.push(p));
+
+  const stmtCount = Math.floor(Math.random() * 3) + 1;
+  const statements = [];
+  for (let i = 0; i < stmtCount; i++) {
+    statements.push('  ' + generateStatement(0, true));
+  }
+
+  // Always add a simple return to avoid syntax issues
+  statements.push('  return ' + generateSimple() + ';');
+
+  // Restore variables
+  declaredVars = savedVars;
+
+  return `function ${name}(${params.join(', ')}) {\n${statements.join('\n')}\n}`;
+}
+
+function generateProgram(options = {}) {
+  const {
+    maxStatements = 8,
+    maxFunctions = 2,
+    includeStrictMode = false
+  } = options;
+
+  declaredVars = [];
+
+  let code = '';
+
+  if (includeStrictMode) {
+    code += "'use strict';\n";
+  }
+
+  // Always declare some initial variables
+  const varCount = Math.floor(Math.random() * 3) + 2;
+  for (let i = 0; i < varCount; i++) {
+    const varName = `var${i}`;
+    declaredVars.push(varName);
+    code += `var ${varName} = ${generateExpression()};\n`;
+  }
+
+  const funcCount = Math.floor(Math.random() * maxFunctions) + 1;
+  for (let i = 0; i < funcCount; i++) {
+    code += generateFunction() + '\n\n';
+  }
+
+  const stmtCount = Math.floor(Math.random() * maxStatements) + 2;
+  for (let i = 0; i < stmtCount; i++) {
+    code += generateStatement() + '\n';
+  }
+
+  // Always end with a result
+  code += `var result = ${generateExpression()};\n`;
+
+  return code;
+}
+
+export { generateExpression as generate, generateStatement, generateFunction, generateProgram };

package/fuzz/index.js

@@ -0,0 +1,270 @@
+import cluster from 'node:cluster';
+import fs from 'node:fs';
+import os from 'node:os';
+import process from 'node:process';
+import { generateProgram } from './generator.js';
+
+const workerDataPath = '/tmp/fuzzWorkerData.json';
+
+if (cluster.isPrimary) {
+  const veryStart = performance.now();
+
+  // Parse CLI arguments
+  let threads = parseInt(process.argv.find(x => x.startsWith('--threads='))?.split('=')?.[1]);
+  if (Number.isNaN(threads)) {
+    threads = Math.max(1, os.cpus().length - 1);
+    console.log(`Using ${threads} threads (detected ${os.cpus().length} CPUs)`);
+  }
+
+  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 verbose = process.argv.includes('--verbose');
+  const saveFailures = process.argv.includes('--save-failures');
+  const plainResults = process.argv.includes('--plain-results');
+
+  console.log(`Starting fuzzer for ${duration}s with ${threads} threads`);
+  console.log(`Max statements: ${maxStatements}, Max functions: ${maxFunctions}`);
+
+  const table = (...arr) => {
+    let out = '';
+    const total = arr[0];
+    for (let i = 0; i < arr.length; i++) {
+      let icon = [ '🧪', '🤠', '❌', '💀', '🏗️', '💥', '⏰', '📝' ][i];
+      let iconDesc = [ 'total', 'pass', 'fail', 'runtime error', 'wasm compile error', 'compile error', 'timeout', 'todo' ][i];
+
+      let data = arr[i];
+      if (i > 0) data = ((data / total) * 100).toPrecision(2) + '%';
+      let str = `${plainResults ? iconDesc : icon} ${data}`;
+      if (i !== arr.length - 1) str += plainResults ? ' | ' : '\u001b[90m | \u001b[0m';
+      out += str;
+    }
+    return out;
+  };
+
+  // Stats tracking - same order as test262
+  let totalTests = 0;
+  let passes = 0;
+  let fails = 0;
+  let runtimeErrors = 0;
+  let wasmErrors = 0;
+  let compileErrors = 0;
+  let timeouts = 0;
+  let todos = 0;
+
+  const errorCounts = new Map();
+  const failureFiles = [];
+
+  const startTime = performance.now();
+  const endTime = startTime + (duration * 1000);
+
+  // Worker data
+  const workerData = {
+    maxStatements,
+    maxFunctions,
+    verbose,
+    saveFailures,
+    endTime
+  };
+  fs.writeFileSync(workerDataPath, JSON.stringify(workerData));
+
+  // Stats display
+  let lastUpdate = 0;
+  const updateInterval = 100;
+  let spinner = ['-', '\\', '|', '/'], spin = 0;
+
+  const updateStats = () => {
+    const now = performance.now();
+    if (now - lastUpdate < updateInterval) return;
+    lastUpdate = now;
+
+    const elapsed = (now - startTime) / 1000;
+    const remaining = Math.max(0, (endTime - now) / 1000);
+    const rate = totalTests / elapsed;
+
+    const tab = ` \u001b[90m${spinner[spin++ % 4]}\u001b[0m  ` +
+      table(totalTests, passes, fails, runtimeErrors, wasmErrors, compileErrors, timeouts, todos);
+
+    process.stdout.write(`\r\u001b[K${tab} | ${rate.toFixed(0)}/s | ${remaining.toFixed(1)}s left`);
+  };
+
+  // Spawn workers with timeout handling like test262
+  const workers = [];
+
+  const spawn = (index) => {
+    const worker = cluster.fork();
+    workers[index] = worker;
+
+    let timeout;
+    const enqueue = () => {
+      if (performance.now() >= endTime) {
+        worker.kill();
+        return;
+      }
+
+      if (timeout) clearTimeout(timeout);
+
+      worker.send(null);
+      timeout = setTimeout(() => {
+        worker.kill();
+
+        totalTests++;
+        timeouts++;
+        errorCounts.set('timeout', (errorCounts.get('timeout') || 0) + 1);
+
+        if (saveFailures) {
+          const timestamp = Date.now();
+          const filename = `fuzz/failure_${timestamp}_timeout.js`;
+          fs.writeFileSync(filename, 'timeout');
+          failureFiles.push(filename);
+        }
+
+        updateStats();
+        spawn(index); // Respawn worker
+      }, 1000);
+    };
+
+    worker.on('message', msg => {
+      if (msg === null) {
+        enqueue();
+        return;
+      }
+
+      if (timeout) clearTimeout(timeout);
+
+      totalTests++;
+
+      // result encoding: pass=0, todo=1, wasmError=2, compileError=3, fail=4, timeout=5, runtimeError=6
+      const result = msg.result;
+
+      if (msg.error) {
+        const error = `${msg.error.name}: ${msg.error.message}`
+          .replace(/\([0-9]+:[0-9]+\)/, '')
+          .replace(/@\+[0-9]+/, '');
+        errorCounts.set(error, (errorCounts.get(error) || 0) + 1);
+      }
+
+      if (result === 0) {
+        passes++;
+      } else if (result === 1) {
+        todos++;
+      } else if (result === 2) {
+        wasmErrors++;
+      } else if (result === 3) {
+        compileErrors++;
+      } else if (result === 4) {
+        fails++;
+      } else if (result === 6) {
+        runtimeErrors++;
+      }
+
+      if (msg.code && (result !== 0 || verbose)) {
+        if (saveFailures && result !== 0) {
+          const timestamp = Date.now();
+          const resultNames = ['pass', 'todo', 'wasmError', 'compileError', 'fail', 'timeout', 'runtimeError'];
+          const filename = `fuzz/failure_${timestamp}_${resultNames[result]}.js`;
+          fs.writeFileSync(filename, msg.code);
+          failureFiles.push(filename);
+        }
+
+        if (verbose && result !== 0) {
+          const resultNames = ['PASS', 'TODO', 'WASM_ERROR', 'COMPILE_ERROR', 'FAIL', 'TIMEOUT', 'RUNTIME_ERROR'];
+          console.log('---');
+          console.log(`\n[${resultNames[result]}] ${msg.error?.message || 'Unknown error'}`);
+          console.log(msg.code);
+          console.log('---');
+        }
+      }
+
+      updateStats();
+      enqueue();
+    });
+  };
+
+  for (let i = 0; i < threads; i++) {
+    spawn(i);
+  }
+
+  // Handle cleanup
+  const cleanup = () => {
+    workers.forEach(worker => worker.kill());
+
+    console.log('\u001b[2F\u001b[0J\u001b[1m\u001b[4mfuzzing complete\u001b[0m');
+
+    console.log(table(totalTests, passes, fails, runtimeErrors, wasmErrors, compileErrors, timeouts, todos) + '\n\n');
+
+    if (errorCounts.size > 0) {
+      const sortedErrors = [...errorCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+      sortedErrors.forEach(([error, count]) => {
+        console.log(`\u001b[90m${((count / totalTests) * 100).toPrecision(2).padStart(6, ' ')}%\u001b[0m \u001b[1m${error}\u001b[0m`);
+      });
+    }
+
+    if (failureFiles.length > 0) {
+      console.log(`\nFailure files saved: ${failureFiles.length}`);
+      failureFiles.slice(0, 5).forEach(file => console.log(`  ${file}`));
+      if (failureFiles.length > 5) console.log(`  ... and ${failureFiles.length - 5} more`);
+    }
+
+    const elapsed = (performance.now() - startTime) / 1000;
+    console.log(`\n\u001b[90mtook ${elapsed.toFixed(1)}s (${(totalTests / elapsed).toFixed(0)} tests/s)\u001b[0m`);
+
+    process.exit(0);
+  };
+
+  // Auto-stop after duration
+  if (duration !== Infinity) setTimeout(cleanup, duration * 1000);
+
+  // Handle Ctrl+C
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+} else {
+  // Worker process
+  let { maxStatements, maxFunctions, verbose, saveFailures, endTime } = JSON.parse(fs.readFileSync(workerDataPath, 'utf8'));
+  endTime ??= Infinity;
+  const compile = (await import('../compiler/wrap.js')).default;
+
+  process.on('message', () => {
+    if (performance.now() >= endTime) {
+      process.exit(0);
+    }
+
+    const code = generateProgram({ maxStatements, maxFunctions });
+
+    let result = 0; // pass
+    let error = null;
+    let stage = 0;
+
+    try {
+      const out = compile(code, false, {});
+
+      try {
+        out.exports.main();
+        stage = 2;
+        result = 0; // pass
+      } catch (runtimeError) {
+        stage = 1;
+        error = runtimeError;
+        result = 6; // runtime error
+      }
+    } catch (compileError) {
+      stage = 0;
+      error = compileError;
+
+      // Classify compile errors same as test262
+      if (compileError.name === 'CompileError') {
+        result = 2; // wasm compile error
+      } else {
+        result = 3; // compile error
+      }
+    }
+
+    process.send({
+      result,
+      error: error ? { name: error.name, message: error.message } : null,
+      code: verbose || saveFailures ? code : null
+    });
+  });
+
+  process.send(null);
+}

package/package.json

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

package/AGENT.md

@@ -1,13 +0,0 @@
-you are an assistant coder for Porffor - a WIP js/ts -> wasm/native ahead-of-time compiler. the codebase is written in js and ts.
-
-IMPORTANT:
-- built-ins apis (Date, String.prototype, etc) are written in ts inside `compiler/builtins`
-- once you update a file inside that directory, you MUST run `./porf precompile` to compile to make your changes effective
-
-test your work using the test262 tools available, iterate independently but do not get stuck on one chain of thought or approach. paths for test262 tools should be relative to the 'test262/test' directory (e.g., 'built-ins/RegExp' instead of 'test262/test/built-ins/RegExp').
-
-- always use single quotes instead of double quotes (unless needed)
-- after finishing, check if your work/diff could be simplified
-- to just evaluate code in the engine, use the command: `./porf -p "..."`
-- to get an overview of the most failing directories, use the command: `node test262/fails.cjs`
-- when working in `compiler/builtins`, inline code instead of using utility/helper functions

package/foo.js

@@ -1,22 +0,0 @@
-// (() => {
-// let y = Math.random();
-// let x = 0;
-// if (x === 0) {
-//   x = 1337;
-// } else {
-//   x = 42;
-// }
-// Porffor.log(x);
-// })()
-
-const fn = function() {}
-
-class C {
-  async *m() { return 42; } a; b = 42;
-  c = fn;
-
-}
-
-new C();
-
-console.log(Object.prototype.hasOwnProperty.call(C, "a"))