printf: remove unneeded Result<> from resolve_asterisk* functions

Author: RenjiSann

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

@@ -315,7 +315,7 @@ impl Spec {
         match self {
             Self::Char { width, align_left } => {
                 let (width, neg_width) =
-                    resolve_asterisk_maybe_negative(*width, &mut args)?.unwrap_or_default();
+                    resolve_asterisk_maybe_negative(*width, &mut args).unwrap_or_default();
                 write_padded(writer, &[args.get_char()], width, *align_left || neg_width)
             }
             Self::String {
@@ -324,15 +324,15 @@ impl Spec {
                 precision,
             } => {
                 let (width, neg_width) =
-                    resolve_asterisk_maybe_negative(*width, &mut args)?.unwrap_or_default();
+                    resolve_asterisk_maybe_negative(*width, &mut args).unwrap_or_default();
 
                 // GNU does do this truncation on a byte level, see for instance:
                 //     printf "%.1s" 🙃
                 //     > �
                 // For now, we let printf panic when we truncate within a code point.
                 // TODO: We need to not use Rust's formatting for aligning the output,
                 // so that we can just write bytes to stdout without panicking.
-                let precision = resolve_asterisk(*precision, &mut args)?;
+                let precision = resolve_asterisk(*precision, &mut args);
                 let s = args.get_str();
                 let truncated = match precision {
                     Some(p) if p < s.len() => &s[..p],
@@ -381,8 +381,8 @@ impl Spec {
                 positive_sign,
                 alignment,
             } => {
-                let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
-                let precision = resolve_asterisk(*precision, &mut args)?.unwrap_or(0);
+                let width = resolve_asterisk(*width, &mut args).unwrap_or(0);
+                let precision = resolve_asterisk(*precision, &mut args).unwrap_or(0);
                 let i = args.get_i64();
 
                 if precision as u64 > i32::MAX as u64 {
@@ -404,8 +404,8 @@ impl Spec {
                 precision,
                 alignment,
             } => {
-                let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
-                let precision = resolve_asterisk(*precision, &mut args)?.unwrap_or(0);
+                let width = resolve_asterisk(*width, &mut args).unwrap_or(0);
+                let precision = resolve_asterisk(*precision, &mut args).unwrap_or(0);
                 let i = args.get_u64();
 
                 if precision as u64 > i32::MAX as u64 {
@@ -430,8 +430,8 @@ impl Spec {
                 alignment,
                 precision,
             } => {
-                let width = resolve_asterisk(*width, &mut args)?.unwrap_or(0);
-                let precision = resolve_asterisk(*precision, &mut args)?.unwrap_or(6);
+                let width = resolve_asterisk(*width, &mut args).unwrap_or(0);
+                let precision = resolve_asterisk(*precision, &mut args).unwrap_or(6);
                 let f = args.get_f64();
 
                 if precision as u64 > i32::MAX as u64 {
@@ -457,19 +457,19 @@ impl Spec {
 fn resolve_asterisk<'a>(
     option: Option<CanAsterisk<usize>>,
     mut args: impl ArgumentIter<'a>,
-) -> Result<Option<usize>, FormatError> {
-    Ok(match option {
+) -> Option<usize> {
+    match option {
         None => None,
         Some(CanAsterisk::Asterisk) => Some(usize::try_from(args.get_u64()).ok().unwrap_or(0)),
         Some(CanAsterisk::Fixed(w)) => Some(w),
-    })
+    }
 }
 
 fn resolve_asterisk_maybe_negative<'a>(
     option: Option<CanAsterisk<usize>>,
     mut args: impl ArgumentIter<'a>,
-) -> Result<Option<(usize, bool)>, FormatError> {
-    Ok(match option {
+) -> Option<(usize, bool)> {
+    match option {
         None => None,
         Some(CanAsterisk::Asterisk) => {
             let nb = args.get_i64();
@@ -480,7 +480,7 @@ fn resolve_asterisk_maybe_negative<'a>(
             }
         }
         Some(CanAsterisk::Fixed(w)) => Some((w, false)),
-    })
+    }
 }
 
 fn write_padded(