Revert all commits after 7905959 (fuzzer changes and dependent fixes)

Reverts 19f6476, 44668b2, 5544004, 04472a5, 737b687, bb9adbd, returning
fuzz.rs, parser, VM string builtins, Cargo.toml, vm.json and the fuzzing
doc to the state at 7905959.

Author: dylan-sutton-chavez

Cargo.toml

@@ -34,4 +34,3 @@ inherits = "release"
 opt-level = 3
 strip = false
 debug = true
-panic = "unwind"

compiler/src/bin/fuzz.rs

@@ -2,13 +2,12 @@ use compiler::modules::lexer::{lex, TokenType};
 use compiler::modules::lexer::tables::token_to_str;
 use compiler::modules::parser::{Parser, SSAChunk};
 use compiler::modules::vm::{VM, Val};
-use std::{panic, sync::mpsc, thread, time::{Duration, Instant, SystemTime}};
+use std::{panic, time::{Duration, Instant, SystemTime}};
 
 const MAX_LEN: usize = 2048;
 const SAVE_DIR: &str = "crashes";
 const PRINT_INTERVAL: u64 = 10_000;
-const MAX_SECS: u64 = 600; // 10 minutes
-const VM_TIMEOUT: Duration = Duration::from_millis(200);
+const MAX_SECS: u64 = 60; // 60 seconds
 const SLOW_THRESHOLD: Duration = Duration::from_millis(50);
 
 struct Rng(u64);
@@ -90,13 +89,11 @@ const BOUNDARIES: [i64; 13] = [
 
 fn boundary_int(rng: &mut Rng) -> i64 { BOUNDARIES[rng.usize_in(BOUNDARIES.len())] }
 
-/* 25% boundary values; rest are full-range random i64 */
 fn rand_int(rng: &mut Rng) -> String {
     if rng.usize_in(4) == 0 { boundary_int(rng).to_string() }
     else { (rng.next() as i64).to_string() }
 }
 
-/* Picks one of ten mutation strategies at uniform random */
 fn mutate(src: &str, corpus: &[String], rng: &mut Rng) -> String {
     match rng.usize_in(10) {
         0 => byte_flip(src, rng),
@@ -121,14 +118,12 @@ fn byte_flip(src: &str, rng: &mut Rng) -> String {
     String::from_utf8_lossy(&bytes).into_owned()
 }
 
-/* Splits into lines, applies f in place, rejoins; shared by drop/duplicate */
 fn with_lines(src: &str, f: impl FnOnce(&mut Vec<&str>)) -> String {
     let mut lines: Vec<&str> = src.lines().collect();
     f(&mut lines);
     lines.join("\n")
 }
 
-/* Injects a keyword snippet at a random line; exercises keywords in unexpected positions */
 fn insert_keyword(src: &str, rng: &mut Rng) -> String {
     let kw = rand_keyword(rng);
     let name = rand_name(rng);
@@ -157,7 +152,6 @@ fn duplicate_line(src: &str, rng: &mut Rng) -> String {
     with_lines(src, |lines| { let idx = rng.usize_in(lines.len()); lines.insert(idx, lines[idx]); })
 }
 
-/* Cross-seeds two corpus entries to produce novel program shapes */
 fn splice(src: &str, corpus: &[String], rng: &mut Rng) -> String {
     if corpus.is_empty() { return src.to_string(); }
     let other = &corpus[rng.usize_in(corpus.len())];
@@ -170,7 +164,6 @@ fn splice(src: &str, corpus: &[String], rng: &mut Rng) -> String {
     out.join("\n")
 }
 
-/* Replaces the first numeric literal with a NaN-box boundary value */
 fn inject_boundary(src: &str, rng: &mut Rng) -> String {
     let boundary = boundary_int(rng).to_string();
     let bytes = src.as_bytes();
@@ -226,7 +219,6 @@ fn indent_bomb(rng: &mut Rng) -> String {
     out
 }
 
-/* Injects a comment line to exercise lexer comment skipping */
 fn add_comment(src: &str, rng: &mut Rng) -> String {
     let comment = format!("# {}", rand_int(rng));
     let mut lines: Vec<&str> = src.lines().collect();
@@ -283,41 +275,34 @@ impl Perf {
     }
 }
 
-enum Outcome { Crash, ParseErr, VmErr, Timeout, Clean(u128, Duration, Duration, Duration) }
+enum Outcome { Crash, ParseErr, VmErr, Clean(u128, Duration, Duration, Duration) }
 
-/* Runs lex→parse→VM in an isolated thread; catches panics and enforces VM_TIMEOUT */
 fn run_once(src: &str) -> Outcome {
-    let src = if src.len() > MAX_LEN { src[..MAX_LEN].to_string() } else { src.to_string() };
-    let (tx, rx) = mpsc::channel();
-    thread::Builder::new().stack_size(8 * 1024 * 1024).spawn(move || {
-        let outcome = match panic::catch_unwind(panic::AssertUnwindSafe(|| {
-            let t0 = Instant::now();
-            let (tokens, _) = lex(&src);
-            let t_lex = t0.elapsed();
-
-            let t1 = Instant::now();
-            let (chunk, errs) = Parser::new(&src, tokens.into_iter()).parse();
-            let t_parse = t1.elapsed();
-
-            let bm = opcode_bitmap(&chunk);
-
-            let t2 = Instant::now();
-            let ok = VM::new(&chunk).run().is_ok();
-            let t_vm = t2.elapsed();
-
-            (errs.is_empty(), ok, bm, t_lex, t_parse, t_vm)
-        })) {
-            Err(_) => Outcome::Crash,
-            Ok((false, ..)) => Outcome::ParseErr,
-            Ok((true, false, ..)) => Outcome::VmErr,
-            Ok((true, true, bm, tl, tp, tv)) => Outcome::Clean(bm, tl, tp, tv),
-        };
-        let _ = tx.send(outcome);
-    });
-    rx.recv_timeout(VM_TIMEOUT).unwrap_or(Outcome::Timeout)
+    let src = if src.len() > MAX_LEN { &src[..MAX_LEN] } else { src };
+    match panic::catch_unwind(panic::AssertUnwindSafe(|| {
+        let t0 = Instant::now();
+        let (tokens, _) = lex(src);
+        let t_lex = t0.elapsed();
+
+        let t1 = Instant::now();
+        let (chunk, errs) = Parser::new(src, tokens.into_iter()).parse();
+        let t_parse = t1.elapsed();
+
+        let bm = opcode_bitmap(&chunk);
+
+        let t2 = Instant::now();
+        let ok = VM::new(&chunk).run().is_ok();
+        let t_vm = t2.elapsed();
+
+        (errs.is_empty(), ok, bm, t_lex, t_parse, t_vm)
+    })) {
+        Err(_) => Outcome::Crash,
+        Ok((false, ..)) => Outcome::ParseErr,
+        Ok((true, false, ..)) => Outcome::VmErr,
+        Ok((true, true, bm, tl, tp, tv)) => Outcome::Clean(bm, tl, tp, tv),
+    }
 }
 
-/* Coverage-guided seed pool; retains inputs that reach new opcodes */
 struct Corpus { entries: Vec<String>, seen: u128 }
 
 impl Corpus {
@@ -333,15 +318,14 @@ impl Corpus {
     }
 }
 
-/* Run counters and start time for the periodic progress display */
-struct Stats { iters: u64, crashes: u64, adds: u64, timeouts: u64, start: Instant }
+struct Stats { iters: u64, crashes: u64, adds: u64, start: Instant }
 
 impl Stats {
-    fn new() -> Self { Self { iters: 0, crashes: 0, adds: 0, timeouts: 0, start: Instant::now() } }
+    fn new() -> Self { Self { iters: 0, crashes: 0, adds: 0, start: Instant::now() } }
     fn print(&self, corpus: usize, perf: &Perf) {
         let s = self.start.elapsed().as_secs_f64().max(0.001);
-        eprintln!("[{:7.1}s] iters={:<9} {:.0}/s  crashes={}  timeouts={}  corpus={}  new_cov={}",
-            s, self.iters, self.iters as f64 / s, self.crashes, self.timeouts, corpus, self.adds);
+        eprintln!("[{:7.1}s] iters={:<9} {:.0}/s  crashes={}  corpus={}  new_cov={}",
+            s, self.iters, self.iters as f64 / s, self.crashes, corpus, self.adds);
         perf.print();
     }
 }
@@ -365,20 +349,19 @@ fn main() {
                 stats.crashes += 1;
                 let path = format!("{SAVE_DIR}/crash_{:06}.py", stats.crashes);
                 let _ = std::fs::write(&path, &input);
-                eprintln!("\n[CRASH #{:06}] -> {path}\n  {:?}\n", stats.crashes, &input[..input.len().min(120)]);
+                eprintln!("\n[CRASH #{:06}] → {path}\n  {:?}\n", stats.crashes, &input[..input.len().min(120)]);
             }
             Outcome::Clean(bm, t_lex, t_parse, t_vm) => {
                 perf.record(t_lex, t_parse, t_vm);
                 let total = t_lex + t_parse + t_vm;
                 if total > SLOW_THRESHOLD {
                     let path = format!("{SAVE_DIR}/slow_{:06}.py", stats.iters);
                     let _ = std::fs::write(&path, &input);
-                    eprintln!("\n[SLOW {}ms] -> {path}\n  lex={}µs parse={}µs vm={}µs\n",
+                    eprintln!("\n[SLOW {}ms] → {path}\n  lex={}µs parse={}µs vm={}µs\n",
                         total.as_millis(), t_lex.as_micros(), t_parse.as_micros(), t_vm.as_micros());
                 }
                 if corpus.add(input, bm) { stats.adds += 1; }
             }
-            Outcome::Timeout => { stats.timeouts += 1; }
             _ => {}
         }
 

compiler/src/modules/parser/mod.rs

@@ -61,7 +61,6 @@ pub struct Parser<'src, I: Iterator<Item = Token>> {
     // `true=for` (PopIter on break), false=while; parallels loop_starts/loop_breaks.
     pub(super) loop_kinds: Vec<bool>,
     pub(super) expr_depth: usize,
-    pub(super) block_depth: usize,
     pub(super) saw_newline: bool,
     /* True inside f-string brace expr; disables `=` assignment so `f"{x=}"` parses as debug form. */
     pub(super) in_fstring_expr: bool,
@@ -460,7 +459,6 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             saw_newline: false,
             in_fstring_expr: false,
             expr_depth: 0,
-            block_depth: 0,
             last_line: 0,
             last_end: 0,
             bracket_stack: Vec::new(),

compiler/src/modules/parser/stmt.rs

@@ -1,7 +1,7 @@
 use crate::s;
 
 use super::Parser;
-use super::types::{OpCode, MAX_BLOCK_DEPTH};
+use super::types::OpCode;
 
 use crate::modules::lexer::{Token, TokenType};
 
@@ -331,15 +331,6 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
 
     /* Compiles Indent/Dedent block; is_body=true stops after ReturnValue to skip dead code. */
     fn compile_block_inner(&mut self, is_body: bool) {
-        if self.block_depth >= MAX_BLOCK_DEPTH {
-            self.errors.push(crate::modules::parser::types::Diagnostic {
-                msg: crate::s!("nesting too deep"),
-                start: self.tokens.peek().map_or(0, |t| t.start),
-                end: self.tokens.peek().map_or(0, |t| t.end),
-            });
-            return;
-        }
-        self.block_depth += 1;
         let indented = self.eat_if(TokenType::Indent);
         loop {
             while self.eat_if(TokenType::Semi) {}
@@ -358,7 +349,6 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
                 if just_returned || !matches!(self.peek(), Some(TokenType::Semi)) { break; }
             } else if !matches!(self.peek(), Some(TokenType::Semi)) { break; }
         }
-        self.block_depth -= 1;
     }
 
     /* Name-led statement: assign, augmented-op, attr, index, call, or tuple unpack. */

compiler/src/modules/parser/types.rs

@@ -5,7 +5,6 @@ use crate::modules::vm::types::ExternFn;
 use alloc::{string::{String, ToString}, vec, vec::Vec};
 
 pub(crate) const MAX_EXPR_DEPTH: usize = 200;
-pub(crate) const MAX_BLOCK_DEPTH: usize = 80;
 pub(crate) const MAX_INSTRUCTIONS: usize = 65_535;
 
 #[derive(Debug, Clone, Copy, PartialEq)]

compiler/src/modules/vm/handlers/builtin_methods/string.rs

@@ -235,7 +235,7 @@ pub fn rpartition(vm: &mut VM, recv: Val, pos: &[Val]) -> Result<(), VmErr> {
 pub fn center(vm: &mut VM, recv: Val, pos: &[Val]) -> Result<(), VmErr> {
     let s = recv_str(vm, recv)?;
     if !pos[0].is_int() { return Err(cold_type("center() width must be an integer")); }
-    let width = pos[0].as_int().clamp(0, 1 << 20) as usize;
+    let width = pos[0].as_int() as usize;
     let fill = if pos.len() > 1 {
         val_to_str(vm, pos[1])?.chars().next().unwrap_or(' ')
     } else { ' ' };
@@ -251,7 +251,7 @@ pub fn center(vm: &mut VM, recv: Val, pos: &[Val]) -> Result<(), VmErr> {
 pub fn zfill(vm: &mut VM, recv: Val, pos: &[Val]) -> Result<(), VmErr> {
     if !pos[0].is_int() { return Err(cold_type("zfill() requires an integer argument")); }
     let s = recv_str(vm, recv)?;
-    let width = pos[0].as_int().clamp(0, 1 << 20) as usize;
+    let width = pos[0].as_int() as usize;
     let nchars = s.chars().count();
     let out = if nchars >= width {
         s

compiler/tests/cases/vm.json

@@ -818,8 +818,6 @@
   {"src": "print('-5'.zfill(4))", "output": ["-005"]},
   {"src": "print('abc'.zfill(5))", "output": ["00abc"]},
   {"src": "print('abc'.zfill(2))", "output": ["abc"]},
-  {"src": "print('abc'.center(-1))", "output": ["abc"]},
-  {"src": "print('abc'.zfill(-1))", "output": ["abc"]},
   {"src": "print('hello'[:])", "output": ["hello"]},
   {"src": "print('hello'[1:])", "output": ["ello"]},
   {"src": "print('hello'[:3])", "output": ["hel"]},

docs/pages/implementation/fuzzing.md

@@ -18,10 +18,9 @@ corpus -> mutate -> lex + parse + vm -> catch_unwind -> [crash | new coverage |
 | `Crash`       | panic anywhere in the pipeline               | save to `crashes/crash_NNNNNN.py`      |
 | `ParseErr`    | parser emitted one or more diagnostics       | discard                                |
 | `VmErr`       | VM returned a typed error                    | discard                                |
-| `Timeout`     | VM did not finish within 200 ms              | discard, increment timeout counter     |
 | `Clean(bm)`   | compiled and executed without panic          | admit to corpus if `bm` covers new opcodes |
 
-`ParseErr`, `VmErr`, and `Timeout` are expected outcomes — typed errors and infinite loops are not bugs. Only an unhandled panic indicates a defect.
+`ParseErr` and `VmErr` are expected outcomes — typed errors are not bugs. Only an unhandled panic indicates a defect.
 
 ## Coverage
 
@@ -31,7 +30,7 @@ An input is admitted to the corpus only when its bitmap introduces at least one
 
 ## Iteration
 
-Some strategies are applied uniformly at random: `byte_flip` (XOR a random byte), `insert_keyword`, `drop_line`, `duplicate_line`, `splice` (join two corpus halves), `inject_boundary` (i64 boundary literals targeting VM overflow), `deep_nest` (100–220 bracket levels, attacks `MAX_EXPR_DEPTH`), `token_shuffle`, `indent_bomb` (50–110 nested `if True:` blocks), and `add_comment`.
+Some sstrategies are applied uniformly at random: `byte_flip` (XOR a random byte), `insert_keyword`, `drop_line`, `duplicate_line`, `splice` (join two corpus halves), `inject_boundary` (i64 boundary literals targeting VM overflow), `deep_nest` (100–220 bracket levels, attacks `MAX_EXPR_DEPTH`), `token_shuffle`, `indent_bomb` (50–110 nested `if True:` blocks), and `add_comment`.
 
 ## Known Targets
 
@@ -58,7 +57,7 @@ The `fuzz` profile inherits from `release` with two overrides: `panic = "unwind"
 Output is written to stderr every 10 000 iterations:
 
 ```txt
-[5.3s]  iters=10000  1886/s  crashes=0  timeouts=2  corpus=24  new_cov=4
+[5.3s]  iters=10000  1886/s  crashes=0  corpus=24  new_cov=4
 ```
 
 Crashes are saved immediately on detection. To reproduce a crash against the standard compiler binary: