fix(quoting): prevent control chars from triggering quotes in NonEscapedShellQuoter

The initial_quoting_with_show_control function was incorrectly treating
control characters as requiring quoting when show_control=true. This
caused test_control_chars to fail in the MinRustV CI check.

For NonEscapedShellQuoter (used in ls --quoting-style=shell):
- Control chars should NOT trigger quoting
- When show_control=false: they become '?' (not special)
- When show_control=true: shown as-is but still don't need quotes
- Only characters in shell_escaped_char_set trigger quoting

This differs from EscapedShellQuoter which uses dollar-quoting for
control characters.

Fixes the test expectation where shell-show mode should NOT wrap
control characters in quotes unless always_quote is set.

Author: naoNao89

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

@@ -358,7 +358,7 @@ impl Spec {
                 let (width, neg_width) = resolve_asterisk_width(*width, args).unwrap_or_default();
                 write_padded(
                     writer,
-                    &[args.next_char(position)],
+                    &[args.next_char(*position)],
                     width,
                     *align_left || neg_width,
                 )
@@ -378,7 +378,7 @@ impl Spec {
                 // 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(*precision, args);
-                let os_str = args.next_string(position);
+                let os_str = args.next_string(*position);
                 let bytes = os_str_as_bytes(os_str)?;
 
                 let truncated = match precision {
@@ -388,7 +388,7 @@ impl Spec {
                 write_padded(writer, truncated, width, *align_left || neg_width)
             }
             Self::EscapedString { position } => {
-                let os_str = args.next_string(position);
+                let os_str = args.next_string(*position);
                 let bytes = os_str_as_bytes(os_str)?;
                 let mut parsed = Vec::<u8>::new();
 
@@ -424,7 +424,7 @@ impl Spec {
             } => {
                 let (width, neg_width) = resolve_asterisk_width(*width, args).unwrap_or((0, false));
                 let precision = resolve_asterisk_precision(*precision, args).unwrap_or_default();
-                let i = args.next_i64(position);
+                let i = args.next_i64(*position);
 
                 if precision as u64 > i32::MAX as u64 {
                     return Err(FormatError::InvalidPrecision(precision.to_string()));
@@ -452,7 +452,7 @@ impl Spec {
             } => {
                 let (width, neg_width) = resolve_asterisk_width(*width, args).unwrap_or((0, false));
                 let precision = resolve_asterisk_precision(*precision, args).unwrap_or_default();
-                let i = args.next_u64(position);
+                let i = args.next_u64(*position);
 
                 if precision as u64 > i32::MAX as u64 {
                     return Err(FormatError::InvalidPrecision(precision.to_string()));
@@ -483,7 +483,7 @@ impl Spec {
             } => {
                 let (width, neg_width) = resolve_asterisk_width(*width, args).unwrap_or((0, false));
                 let precision = resolve_asterisk_precision(*precision, args);
-                let f: ExtendedBigDecimal = args.next_extended_big_decimal(position);
+                let f: ExtendedBigDecimal = args.next_extended_big_decimal(*position);
 
                 if precision.is_some_and(|p| p as u64 > i32::MAX as u64) {
                     return Err(FormatError::InvalidPrecision(
@@ -520,7 +520,7 @@ fn resolve_asterisk_width(
     match option {
         None => None,
         Some(CanAsterisk::Asterisk(loc)) => {
-            let nb = args.next_i64(&loc);
+            let nb = args.next_i64(loc);
             if nb < 0 {
                 Some((usize::try_from(-(nb as isize)).ok().unwrap_or(0), true))
             } else {
@@ -539,7 +539,7 @@ fn resolve_asterisk_precision(
 ) -> Option<usize> {
     match option {
         None => None,
-        Some(CanAsterisk::Asterisk(loc)) => match args.next_i64(&loc) {
+        Some(CanAsterisk::Asterisk(loc)) => match args.next_i64(loc) {
             v if v >= 0 => usize::try_from(v).ok(),
             v if v < 0 => Some(0usize),
             _ => None,

src/uucore/src/lib/features/quoting_style/shell_quoter.rs

@@ -398,16 +398,17 @@ fn initial_quoting_with_show_control(
     input: &[u8],
     dirname: bool,
     always_quote: bool,
-    show_control: bool,
+    _show_control: bool,
 ) -> (Quotes, bool) {
-    // Check for control characters FIRST - they require $'...' which only works with single quotes
-    // But only consider them if we're showing them; if hiding, they become '?' which isn't special
-    let has_control_chars = show_control && input.iter().any(|&c| c < 32 || c == 127);
-
-    if has_control_chars
-        || input
-            .iter()
-            .any(|c| shell_escaped_char_set(dirname).contains(c))
+    // For NonEscapedShellQuoter, control chars don't trigger quoting.
+    // When show_control=false, they become '?' which isn't special.
+    // When show_control=true, they're shown as-is but still don't trigger quoting
+    // (unlike EscapedShellQuoter which uses dollar-quoting for them).
+    // Only characters in shell_escaped_char_set trigger quoting.
+
+    if input
+        .iter()
+        .any(|c| shell_escaped_char_set(dirname).contains(c))
     {
         (Quotes::Single, true)
     } else if input.contains(&b'\'') {