fix(lib/common): two latent correctness bugs in stdin/radix paths (refs #22) (#24)

Two bugs flagged by clippy's correctness lints that would each cause
real runtime failure given the right input -- not just style nits:

1. `read_all_lines` in lib/common/io.rs spun forever on a broken stdin.
   `BufRead::lines()` returns an `io::Lines` iterator that, once the
   underlying reader yields an error, keeps yielding the same `Err`
   forever. The old `filter_map(|l| l.ok())` swallowed every `Err` and
   asked for the next one -- so a single decoding error or closed
   handle made the function never return. Swapped to
   `map_while(Result::ok)` so the iterator terminates at the first
   error (clippy::lines_filter_map_ok).

2. `int_to_string_radix` (string.rs:209) and `int_to_str_radix`
   (types.rs:103) both did `n.abs() as u64`, which panics in debug on
   `i64::MIN` because `i64::MIN.abs()` overflows (the magnitude
   9_223_372_036_854_775_808 doesn't fit in `i64`). Swapped to
   `n.unsigned_abs()`, which returns the magnitude as `u64` directly
   and is defined for every `i64` (clippy::cast_abs_to_unsigned).

Regression tests added for the radix-conversion bug:

* `test_radix_i64_min_does_not_panic` in lib/common/string.rs
* `test_int_to_str_radix_i64_min_does_not_panic` in lib/common/types.rs

Both formerly panicked in debug builds (the test process aborted with
"attempt to negate with overflow"); both now round-trip to
"-9223372036854775808".

`read_all_lines` is harder to regression-test in unit tests since it
reads real stdin; the behavior change is verified by the swapped
iterator combinator and clippy no longer flagging that site.

Part 2 of 4 from #22. Off clean origin/main; does not depend on PR1
(#23).

Author: hyperpolymath

crates/my-lang/lib/common/io.rs

@@ -36,12 +36,17 @@ pub fn read_line_prompt(prompt: &str) -> String {
     read_line()
 }
 
-/// Read all lines from stdin until EOF
+/// Read all lines from stdin until EOF.
+///
+/// Uses `map_while(Result::ok)` rather than `filter_map(Result::ok)` so a
+/// broken or non-UTF-8 stdin terminates the iterator at the first error
+/// instead of spinning forever -- `io::Lines` keeps yielding the same
+/// `Err` indefinitely once the underlying reader fails.
 pub fn read_all_lines() -> Vec<String> {
     io::stdin()
         .lock()
         .lines()
-        .filter_map(|l| l.ok())
+        .map_while(Result::ok)
         .collect()
 }
 

crates/my-lang/lib/common/string.rs

@@ -206,7 +206,10 @@ pub fn int_to_string_radix(n: i64, radix: u32) -> Option<String> {
     }
 
     let mut result = String::new();
-    let mut num = n.abs() as u64;
+    // `unsigned_abs` instead of `n.abs() as u64`: the latter panics in debug
+    // on `i64::MIN` because `i64::MIN.abs()` overflows. `unsigned_abs`
+    // returns the absolute value as a `u64` losslessly for every `i64`.
+    let mut num = n.unsigned_abs();
 
     while num > 0 {
         let digit = (num % radix as u64) as u32;
@@ -305,4 +308,14 @@ mod tests {
         assert_eq!(int_to_string_radix(255, 16), Some("ff".to_string()));
         assert_eq!(int_to_string_radix(10, 2), Some("1010".to_string()));
     }
+
+    #[test]
+    fn test_radix_i64_min_does_not_panic() {
+        // Regression for `n.abs() as u64` panicking on `i64::MIN` in debug
+        // builds. After the switch to `unsigned_abs`, this must round-trip.
+        assert_eq!(
+            int_to_string_radix(i64::MIN, 10),
+            Some("-9223372036854775808".to_string())
+        );
+    }
 }

crates/my-lang/lib/common/types.rs

@@ -100,7 +100,10 @@ pub fn int_to_str_radix(n: i64, radix: u32) -> Option<String> {
     }
 
     let mut result = String::new();
-    let mut num = n.abs() as u64;
+    // `unsigned_abs` instead of `n.abs() as u64`: the latter panics in debug
+    // on `i64::MIN` because `i64::MIN.abs()` overflows. `unsigned_abs`
+    // returns the absolute value as a `u64` losslessly for every `i64`.
+    let mut num = n.unsigned_abs();
 
     while num > 0 {
         let digit = (num % radix as u64) as u32;
@@ -312,6 +315,16 @@ mod tests {
         assert_eq!(int_to_str_radix(255, 16), Some("ff".to_string()));
     }
 
+    #[test]
+    fn test_int_to_str_radix_i64_min_does_not_panic() {
+        // Regression for `n.abs() as u64` panicking on `i64::MIN` in debug
+        // builds. After the switch to `unsigned_abs`, this must round-trip.
+        assert_eq!(
+            int_to_str_radix(i64::MIN, 10),
+            Some("-9223372036854775808".to_string())
+        );
+    }
+
     #[test]
     fn test_bool_conversions() {
         assert_eq!(str_to_bool("true"), Some(true));