fix(jtv): sweep .expect("TODO: handle error") — 108 sites cleared

Eliminated all 108 instances of TODO-placeholder error handling:

**Test code (61 sites, Policy a: .unwrap())**
  - number.rs: 8 test assertions → .unwrap()
  - wasm.rs: 17 test assertions → .unwrap()
  - interpreter.rs: 11 test assertions → .unwrap()
  - typechecker.rs: 4 test assertions → .unwrap()
  - formatter.rs: 9 test assertions → .unwrap()
  - purity.rs: 6 test assertions → .unwrap()
  - reversible.rs: 6 test assertions → .unwrap()

**Production parser code (47 sites, Policy c: error propagation)**
  - parser.rs: All .next() calls on Pest parser iterators converted from
    .expect("TODO: handle error") to .ok_or_else() with meaningful error
    messages that propagate through the Result type system.
  - Key functions updated: parse_module, parse_import, parse_function,
    parse_param, parse_control_stmt, parse_reversible_stmt, parse_data_expr,
    parse_additive_expr, parse_term, parse_factor, parse_control_expr,
    parse_logical_expr, parse_logical_term, parse_logical_factor,
    parse_comparison_expr, parse_range_expr, parse_type_annotation.
  - Each error site now reports what was expected (e.g., "Expected module name",
    "Expected function declaration", "Expected parameter name").

Tests: 84 passed; 0 failed

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

crates/jtv-core/src/formatter.rs

@@ -536,52 +536,52 @@ mod tests {
     #[test]
     fn test_format_simple_assignment() {
         let code = "x=5+3";
-        let formatted = format_code(code).expect("TODO: handle error");
+        let formatted = format_code(code).unwrap();
         assert_eq!(formatted, "x = 5 + 3\n");
     }
 
     #[test]
     fn test_format_function() {
         let code = "fn add(a:Int,b:Int):Int{return a+b}";
-        let formatted = format_code(code).expect("TODO: handle error");
+        let formatted = format_code(code).unwrap();
         assert!(formatted.contains("fn add(a: Int, b: Int): Int {"));
         assert!(formatted.contains("return a + b"));
     }
 
     #[test]
     fn test_format_if_statement() {
         let code = "if x>0{y=1}";
-        let formatted = format_code(code).expect("TODO: handle error");
+        let formatted = format_code(code).unwrap();
         assert!(formatted.contains("if x > 0 {"));
         assert!(formatted.contains("y = 1"));
     }
 
     #[test]
     fn test_format_pure_function() {
         let code = "@pure fn double(x:Int):Int{return x+x}";
-        let formatted = format_code(code).expect("TODO: handle error");
+        let formatted = format_code(code).unwrap();
         assert!(formatted.contains("@pure fn double"));
     }
 
     #[test]
     fn test_format_reverse_block() {
         let code = "reverse{x+=5}";
-        let formatted = format_code(code).expect("TODO: handle error");
+        let formatted = format_code(code).unwrap();
         assert!(formatted.contains("reverse {"));
         assert!(formatted.contains("x += 5"));
     }
 
     #[test]
     fn test_format_list() {
         let code = "nums=[1,2,3,4,5]";
-        let formatted = format_code(code).expect("TODO: handle error");
+        let formatted = format_code(code).unwrap();
         assert_eq!(formatted, "nums = [1, 2, 3, 4, 5]\n");
     }
 
     #[test]
     fn test_format_for_loop() {
         let code = "for i in 0..10{x=x+i}";
-        let formatted = format_code(code).expect("TODO: handle error");
+        let formatted = format_code(code).unwrap();
         assert!(formatted.contains("for i in 0..10 {"));
     }
 
@@ -592,14 +592,14 @@ mod tests {
             spaces_around_operators: false,
             ..Default::default()
         };
-        let formatted = format_code_with_config(code, config).expect("TODO: handle error");
+        let formatted = format_code_with_config(code, config).unwrap();
         assert_eq!(formatted, "x=5+3\n");
     }
 
     #[test]
     fn test_format_while_loop() {
         let code = "while x>0{x=x+-1}";
-        let formatted = format_code(code).expect("TODO: handle error");
+        let formatted = format_code(code).unwrap();
         assert!(formatted.contains("while x > 0 {"));
         assert!(formatted.contains("x = x + -1"));
     }

crates/jtv-core/src/interpreter.rs

@@ -548,11 +548,11 @@ mod tests {
     #[test]
     fn test_simple_addition() {
         let code = "x = 5 + 3";
-        let program = parse_program(code).expect("TODO: handle error");
+        let program = parse_program(code).unwrap();
         let mut interpreter = Interpreter::new();
-        interpreter.run(&program).expect("TODO: handle error");
+        interpreter.run(&program).unwrap();
 
-        let x = interpreter.get_variable("x").expect("TODO: handle error");
+        let x = interpreter.get_variable("x").unwrap();
         assert_eq!(x, Value::Int(8));
     }
 
@@ -566,11 +566,11 @@ fn add(a: Int, b: Int): Int {
 result = add(5, 3)
         "#;
 
-        let program = parse_program(code).expect("TODO: handle error");
+        let program = parse_program(code).unwrap();
         let mut interpreter = Interpreter::new();
-        interpreter.run(&program).expect("TODO: handle error");
+        interpreter.run(&program).unwrap();
 
-        let result = interpreter.get_variable("result").expect("TODO: handle error");
+        let result = interpreter.get_variable("result").unwrap();
         assert_eq!(result, Value::Int(8));
     }
 
@@ -583,10 +583,10 @@ fn double(x: Int): Int {
 }
         "#;
 
-        let program = parse_program(code).expect("TODO: handle error");
+        let program = parse_program(code).unwrap();
         let mut interpreter = Interpreter::new();
         // Just test that it parses and runs without calling
-        interpreter.run(&program).expect("TODO: handle error");
+        interpreter.run(&program).unwrap();
     }
 
     #[test]
@@ -598,11 +598,11 @@ fn double(x: Int): Int {
             }
         "#;
 
-        let program = parse_program(code).expect("TODO: handle error");
+        let program = parse_program(code).unwrap();
         let mut interpreter = Interpreter::new();
-        interpreter.run(&program).expect("TODO: handle error");
+        interpreter.run(&program).unwrap();
 
-        let sum = interpreter.get_variable("sum").expect("TODO: handle error");
+        let sum = interpreter.get_variable("sum").unwrap();
         assert_eq!(sum, Value::Int(15)); // 1+2+3+4+5
     }
 }

crates/jtv-core/src/number.rs

@@ -274,63 +274,63 @@ mod tests {
     fn test_int_addition() {
         let a = Value::Int(5);
         let b = Value::Int(3);
-        let result = a.add(&b).expect("TODO: handle error");
+        let result = a.add(&b).unwrap();
         assert_eq!(result, Value::Int(8));
     }
 
     #[test]
     fn test_float_addition() {
         let a = Value::Float(5.5);
         let b = Value::Float(3.2);
-        let result = a.add(&b).expect("TODO: handle error");
+        let result = a.add(&b).unwrap();
         assert!(matches!(result, Value::Float(_)));
     }
 
     #[test]
     fn test_rational_addition() {
         let a = Value::Rational(Ratio::new(1, 2));
         let b = Value::Rational(Ratio::new(1, 3));
-        let result = a.add(&b).expect("TODO: handle error");
+        let result = a.add(&b).unwrap();
         assert_eq!(result, Value::Rational(Ratio::new(5, 6)));
     }
 
     #[test]
     fn test_complex_addition() {
         let a = Value::Complex(Complex64::new(1.0, 2.0));
         let b = Value::Complex(Complex64::new(3.0, 4.0));
-        let result = a.add(&b).expect("TODO: handle error");
+        let result = a.add(&b).unwrap();
         assert_eq!(result, Value::Complex(Complex64::new(4.0, 6.0)));
     }
 
     #[test]
     fn test_hex_addition() {
         let a = Value::Hex(0x10);
         let b = Value::Hex(0x20);
-        let result = a.add(&b).expect("TODO: handle error");
+        let result = a.add(&b).unwrap();
         assert_eq!(result, Value::Hex(0x30));
     }
 
     #[test]
     fn test_binary_addition() {
         let a = Value::Binary(0b1010);
         let b = Value::Binary(0b0101);
-        let result = a.add(&b).expect("TODO: handle error");
+        let result = a.add(&b).unwrap();
         assert_eq!(result, Value::Binary(0b1111));
     }
 
     #[test]
     fn test_symbolic_addition() {
         let a = Value::Symbolic("x".to_string());
         let b = Value::Symbolic("y".to_string());
-        let result = a.add(&b).expect("TODO: handle error");
+        let result = a.add(&b).unwrap();
         assert_eq!(result, Value::Symbolic("x + y".to_string()));
     }
 
     #[test]
     fn test_type_coercion() {
         let a = Value::Int(5);
         let b = Value::Float(3.5);
-        let result = a.add(&b).expect("TODO: handle error");
+        let result = a.add(&b).unwrap();
         assert!(matches!(result, Value::Float(_)));
     }
 }