core: optimise Debug impl for ascii::Char

Rather than writing character at a time, optimise Debug implementation
for core::ascii::Char such that it writes the entire representation as
with a single write_str call.

With that, add tests for Display and Debug implementations.

Author: mina86

library/core/src/ascii/ascii_char.rs

@@ -3,7 +3,7 @@
 //! suggestions from rustc if you get anything slightly wrong in here, and overall
 //! helps with clarity as we're also referring to `char` intentionally in here.
 
-use crate::fmt::{self, Write};
+use crate::fmt;
 use crate::mem::transmute;
 
 /// One of the 128 Unicode characters from U+0000 through U+007F,
@@ -567,9 +567,10 @@ impl fmt::Display for AsciiChar {
 #[unstable(feature = "ascii_char", issue = "110998")]
 impl fmt::Debug for AsciiChar {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        #[inline]
-        fn backslash(a: AsciiChar) -> ([AsciiChar; 4], u8) {
-            ([AsciiChar::ReverseSolidus, a, AsciiChar::Null, AsciiChar::Null], 2)
+        use AsciiChar::{Apostrophe, Null, ReverseSolidus as Backslash};
+
+        fn backslash(a: AsciiChar) -> ([AsciiChar; 6], usize) {
+            ([Apostrophe, Backslash, a, Apostrophe, Null, Null], 4)
         }
 
         let (buf, len) = match self {
@@ -579,24 +580,17 @@ impl fmt::Debug for AsciiChar {
             AsciiChar::LineFeed => backslash(AsciiChar::SmallN),
             AsciiChar::ReverseSolidus => backslash(AsciiChar::ReverseSolidus),
             AsciiChar::Apostrophe => backslash(AsciiChar::Apostrophe),
-            _ => {
-                let byte = self.to_u8();
-                if !byte.is_ascii_control() {
-                    ([*self, AsciiChar::Null, AsciiChar::Null, AsciiChar::Null], 1)
-                } else {
-                    const HEX_DIGITS: [AsciiChar; 16] = *b"0123456789abcdef".as_ascii().unwrap();
+            _ if self.to_u8().is_ascii_control() => {
+                const HEX_DIGITS: [AsciiChar; 16] = *b"0123456789abcdef".as_ascii().unwrap();
 
-                    let hi = HEX_DIGITS[usize::from(byte >> 4)];
-                    let lo = HEX_DIGITS[usize::from(byte & 0xf)];
-                    ([AsciiChar::ReverseSolidus, AsciiChar::SmallX, hi, lo], 4)
-                }
-            }
+                let byte = self.to_u8();
+                let hi = HEX_DIGITS[usize::from(byte >> 4)];
+                let lo = HEX_DIGITS[usize::from(byte & 0xf)];
+                ([Apostrophe, Backslash, AsciiChar::SmallX, hi, lo, Apostrophe], 6)
+            },
+            _ => ([Apostrophe, *self, Apostrophe, Null, Null, Null], 3),
         };
 
-        f.write_char('\'')?;
-        for byte in &buf[..len as usize] {
-            f.write_str(byte.as_str())?;
-        }
-        f.write_char('\'')
+        f.write_str(buf[..len].as_str())
     }
 }

library/core/tests/ascii_char.rs

@@ -0,0 +1,68 @@
+use core::ascii::Char;
+use core::fmt::Write;
+
+/// Tests Display implementation for ascii::Char.
+#[test]
+fn test_display() {
+    let want = (0..128u8).map(|b| b as char).collect::<String>();
+    let mut got = String::with_capacity(128);
+    for byte in 0..128 {
+        write!(&mut got, "{}", Char::from_u8(byte).unwrap()).unwrap();
+    }
+    assert_eq!(want, got);
+}
+
+/// Tests Debug implementation for ascii::Char.
+#[test]
+fn test_debug() {
+    for (chr, want) in [
+        // Control characters
+        (Char::Null, r#"'\0'"#),
+        (Char::StartOfHeading, r#"'\x01'"#),
+        (Char::StartOfText, r#"'\x02'"#),
+        (Char::EndOfText, r#"'\x03'"#),
+        (Char::EndOfTransmission, r#"'\x04'"#),
+        (Char::Enquiry, r#"'\x05'"#),
+        (Char::Acknowledge, r#"'\x06'"#),
+        (Char::Bell, r#"'\x07'"#),
+        (Char::Backspace, r#"'\x08'"#),
+        (Char::CharacterTabulation, r#"'\t'"#),
+        (Char::LineFeed, r#"'\n'"#),
+        (Char::LineTabulation, r#"'\x0b'"#),
+        (Char::FormFeed, r#"'\x0c'"#),
+        (Char::CarriageReturn, r#"'\r'"#),
+        (Char::ShiftOut, r#"'\x0e'"#),
+        (Char::ShiftIn, r#"'\x0f'"#),
+        (Char::DataLinkEscape, r#"'\x10'"#),
+        (Char::DeviceControlOne, r#"'\x11'"#),
+        (Char::DeviceControlTwo, r#"'\x12'"#),
+        (Char::DeviceControlThree, r#"'\x13'"#),
+        (Char::DeviceControlFour, r#"'\x14'"#),
+        (Char::NegativeAcknowledge, r#"'\x15'"#),
+        (Char::SynchronousIdle, r#"'\x16'"#),
+        (Char::EndOfTransmissionBlock, r#"'\x17'"#),
+        (Char::Cancel, r#"'\x18'"#),
+        (Char::EndOfMedium, r#"'\x19'"#),
+        (Char::Substitute, r#"'\x1a'"#),
+        (Char::Escape, r#"'\x1b'"#),
+        (Char::InformationSeparatorFour, r#"'\x1c'"#),
+        (Char::InformationSeparatorThree, r#"'\x1d'"#),
+        (Char::InformationSeparatorTwo, r#"'\x1e'"#),
+        (Char::InformationSeparatorOne, r#"'\x1f'"#),
+        // U+007F is also a control character
+        (Char::Delete, r#"'\x7f'"#),
+
+        // Characters which need escaping.
+        (Char::ReverseSolidus, r#"'\\'"#),
+        (Char::Apostrophe, r#"'\''"#),
+
+        // Regular, non-control characters, which don’t need any special
+        // handling.
+        (Char::Space, r#"' '"#),
+        (Char::QuotationMark, r#"'"'"#),
+        (Char::CapitalM, r#"'M'"#),
+        (Char::Tilde, r#"'~'"#),
+    ] {
+        assert_eq!(want, format!("{chr:?}"), "chr: {}", chr as u8);
+    }
+}

library/core/tests/lib.rs

@@ -126,6 +126,7 @@ mod alloc;
 mod any;
 mod array;
 mod ascii;
+mod ascii_char;
 mod asserting;
 mod async_iter;
 mod atomic;