fix(printf): compute asterisk width magnitude in unsigned arithmetic

A negative '*' field width argument of i64::MIN used to panic with
attempt to negate with overflow because |i64::MIN| = 2^63 is not
representable in i64/isize. Use nb.unsigned_abs() to compute the
magnitude in unsigned arithmetic, which can represent 2^63.

Add a unit test for the width resolution and an end-to-end regression
test verifying printf fails gracefully with a write error instead of
panicking.

Fixes #13766

Author: almogyalin

src/uucore/src/lib/features/format/spec.rs

@@ -511,7 +511,8 @@ fn resolve_asterisk_width(
         Some(CanAsterisk::Asterisk(loc)) => {
             let nb = args.next_i64(loc);
             if nb < 0 {
-                Some((usize::try_from(-(nb as isize)).ok().unwrap_or(0), true))
+                // Unsigned arithmetic, so `i64::MIN` (magnitude 2^63) doesn't overflow.
+                Some((usize::try_from(nb.unsigned_abs()).ok().unwrap_or(0), true))
             } else {
                 Some((usize::try_from(nb).ok().unwrap_or(0), false))
             }
@@ -670,6 +671,26 @@ mod tests {
                 )
             );
         }
+
+        #[test]
+        fn asterisk_i64_min_width() {
+            // Regression test for https://github.com/uutils/coreutils/issues/13766
+            // |i64::MIN| = 2^63 overflows i64, so the magnitude of a negative
+            // `*` width must be computed in unsigned arithmetic.
+            let expected = usize::try_from(i64::MIN.unsigned_abs()).unwrap_or(0);
+            for arg in [
+                FormatArgument::SignedInt(i64::MIN),
+                FormatArgument::Unparsed(i64::MIN.to_string().into()),
+            ] {
+                assert_eq!(
+                    Some((expected, true)),
+                    resolve_asterisk_width(
+                        Some(CanAsterisk::Asterisk(ArgumentLocation::NextArgument)),
+                        &mut FormatArguments::new(&[arg]),
+                    )
+                );
+            }
+        }
     }
 
     mod resolve_asterisk_precision {

tests/by-util/test_printf.rs

@@ -1538,6 +1538,22 @@ fn test_extreme_field_width_overflow() {
         .stderr_contains("printf: write error"); //could contains additional message like "formatting width too large" not in GNU, thats fine.
 }
 
+#[test]
+fn test_asterisk_width_i64_min_no_panic() {
+    // Regression test for https://github.com/uutils/coreutils/issues/13766
+    // An `i64::MIN` '*' width used to panic with "attempt to negate with overflow".
+    // It must not panic: on 64-bit it fails with a write error, on 32-bit the
+    // width is clamped to 0 and printf succeeds.
+    let result = new_ucmd!()
+        .args(&["|%*d|", &i64::MIN.to_string(), "1"])
+        .run();
+    assert!(
+        result.succeeded() || result.code() == 1,
+        "printf must not panic on an i64::MIN '*' width (got exit code {})",
+        result.code()
+    );
+}
+
 #[test]
 fn test_q_string_control_chars_with_quotes() {
     // Test %q with control characters and single quotes combined.