fix(date): add error handling for format modifier width overflow

Added proper error handling for format modifier width calculations that could overflow or fail allocation. The change replaces generic error messages with a specific error type `FieldWidthTooLarge` that includes the problematic width and specifier values, improving error reporting for date format operations.

Author: mattsu2020

src/uu/date/locales/en-US.ftl

@@ -106,6 +106,7 @@ date-error-setting-date-not-supported-redox = setting the date is not supported
 date-error-cannot-set-date = cannot set date
 date-error-extra-operand = extra operand '{$operand}'
 date-error-write = write error: {$error}
+date-error-format-modifier-width-too-large = format modifier width '{$width}' is too large for specifier '%{$specifier}'
 date-error-format-missing-plus = the argument {$arg} lacks a leading '+';
   when using an option to specify date(s), any non-option
   argument must be a format string beginning with '+'

src/uu/date/locales/fr-FR.ftl

@@ -101,6 +101,7 @@ date-error-setting-date-not-supported-redox = la définition de la date n'est pa
 date-error-cannot-set-date = impossible de définir la date
 date-error-extra-operand = opérande supplémentaire '{$operand}'
 date-error-write = erreur d'écriture: {$error}
+date-error-format-modifier-width-too-large = la largeur du modificateur de format '{$width}' est trop grande pour le spécificateur '%{$specifier}'
 date-error-format-missing-plus = l'argument {$arg} ne commence pas par un signe '+';
  lorsqu'une option est utilisée pour spécifier une ou plusieurs dates, tout argument autre
   qu'une option doit être une chaîne de format commençant par un signe '+'.

src/uu/date/src/format_modifiers.rs

@@ -38,21 +38,30 @@ use jiff::fmt::strtime::{BrokenDownTime, Config, PosixCustom};
 use regex::Regex;
 use std::fmt;
 use std::sync::OnceLock;
+use uucore::translate;
 
 /// Error type for format modifier operations
 #[derive(Debug)]
 pub enum FormatError {
     /// Error from the underlying jiff library
     JiffError(jiff::Error),
-    /// Custom error message
-    Custom(String),
+    /// Field width calculation overflowed or required allocation failed
+    FieldWidthTooLarge { width: usize, specifier: String },
 }
 
 impl fmt::Display for FormatError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::JiffError(e) => write!(f, "{e}"),
-            Self::Custom(s) => write!(f, "{s}"),
+            Self::FieldWidthTooLarge { width, specifier } => write!(
+                f,
+                "{}",
+                translate!(
+                    "date-error-format-modifier-width-too-large",
+                    "width" => width,
+                    "specifier" => specifier
+                )
+            ),
         }
     }
 }
@@ -63,12 +72,6 @@ impl From<jiff::Error> for FormatError {
     }
 }
 
-const ERR_FIELD_WIDTH_TOO_LARGE: &str = "field width too large";
-
-fn width_too_large_error() -> FormatError {
-    FormatError::Custom(ERR_FIELD_WIDTH_TOO_LARGE.to_string())
-}
-
 /// Regex to match format specifiers with optional modifiers
 /// Pattern: % \[flags\] \[width\] specifier
 /// Flags: -, _, 0, ^, #, +
@@ -392,28 +395,38 @@ fn apply_modifiers(
             // Zero padding: sign first, then zeros (e.g., "-0022")
             let sign = result.chars().next().unwrap();
             let rest = &result[1..];
-            let target_len = result
-                .len()
-                .checked_add(padding)
-                .ok_or_else(width_too_large_error)?;
+            let target_len = result.len().checked_add(padding).ok_or_else(|| {
+                FormatError::FieldWidthTooLarge {
+                    width,
+                    specifier: specifier.to_string(),
+                }
+            })?;
             let mut padded = String::new();
             padded
                 .try_reserve(target_len)
-                .map_err(|_| width_too_large_error())?;
+                .map_err(|_| FormatError::FieldWidthTooLarge {
+                    width,
+                    specifier: specifier.to_string(),
+                })?;
             padded.push(sign);
             padded.extend(std::iter::repeat_n('0', padding));
             padded.push_str(rest);
             result = padded;
         } else {
             // Default: pad on the left (e.g., "  -22" or "  1999")
-            let target_len = result
-                .len()
-                .checked_add(padding)
-                .ok_or_else(width_too_large_error)?;
+            let target_len = result.len().checked_add(padding).ok_or_else(|| {
+                FormatError::FieldWidthTooLarge {
+                    width,
+                    specifier: specifier.to_string(),
+                }
+            })?;
             let mut padded = String::new();
             padded
                 .try_reserve(target_len)
-                .map_err(|_| width_too_large_error())?;
+                .map_err(|_| FormatError::FieldWidthTooLarge {
+                    width,
+                    specifier: specifier.to_string(),
+                })?;
             padded.extend(std::iter::repeat_n(pad_char, padding));
             padded.push_str(&result);
             result = padded;
@@ -775,7 +788,8 @@ mod tests {
         let err = apply_modifiers("x", "", usize::MAX, "c", true).unwrap_err();
         assert!(matches!(
             err,
-            FormatError::Custom(message) if message == ERR_FIELD_WIDTH_TOO_LARGE
+            FormatError::FieldWidthTooLarge { width, specifier }
+            if width == usize::MAX && specifier == "c"
         ));
     }
 }

tests/by-util/test_date.rs

@@ -2509,12 +2509,10 @@ fn test_date_format_modifier_edge_cases() {
 
 #[test]
 fn test_date_format_modifier_huge_width_fails_without_abort() {
+    // GNU date also exits with failure for extremely large width.
+    // Assert exit code only to avoid coupling to implementation-specific error text.
     let format = format!("+%{}c", usize::MAX);
-    new_ucmd!()
-        .arg(&format)
-        .fails()
-        .code_is(1)
-        .stderr_contains("field width too large");
+    new_ucmd!().arg(&format).fails().code_is(1);
 }
 
 // Tests for --debug flag