refactor: make string formatting more readable

To make the final output code easier to see:
* Get rid of the unnecessary line-noise of `.unwrap()`ing calls to
  `write!()` by moving the `.unwrap()` into a macro.
* Join consecutive `write!()` calls using a single multiline format
  string.
* Replace `.push()` and `.push_str(format!())` with `write!()`.
* If after doing all of the above, there is only a single `write!()`
  call in the function, just construct the string directly with
  `format!()`.

Author: Kmeakin

library/core/src/unicode/unicode_data.rs

@@ -12,6 +12,7 @@
 // Total           : 31911 bytes
 
 pub const UNICODE_VERSION: (u8, u8, u8) = (17, 0, 0);
+
 use super::rt::*;
 
 pub mod alphabetic {
@@ -129,6 +130,7 @@ pub mod alphabetic {
         1, 10, 1, 17, 5, 3, 1, 5, 1, 17, 0, 26, 6, 26, 6, 26, 0, 0, 32, 0, 2, 0, 2, 0, 15, 0, 0, 0,
         0, 0, 5, 0, 0,
     ];
+
     #[inline]
     pub fn lookup(c: char) -> bool {
         debug_assert!(!c.is_ascii());
@@ -228,6 +230,7 @@ pub mod case_ignorable {
         1, 17, 2, 7, 1, 2, 1, 5, 5, 62, 33, 1, 160, 14, 0, 1, 61, 4, 0, 5, 254, 2, 243, 1, 2, 1, 7,
         2, 5, 1, 9, 1, 0, 7, 109, 8, 0, 5, 0, 1, 30, 96, 128, 240, 0,
     ];
+
     #[inline]
     pub fn lookup(c: char) -> bool {
         debug_assert!(!c.is_ascii());
@@ -291,6 +294,7 @@ pub mod cased {
         7, 1, 0, 2, 25, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 31, 1, 25, 1, 8, 0, 10,
         1, 20, 6, 6, 0, 62, 0, 68, 0, 26, 6, 26, 6, 26, 0,
     ];
+
     #[inline]
     pub fn lookup(c: char) -> bool {
         debug_assert!(!c.is_ascii());
@@ -381,6 +385,7 @@ pub mod grapheme_extend {
         4, 50, 8, 1, 14, 1, 22, 5, 1, 15, 0, 7, 1, 17, 2, 7, 1, 2, 1, 5, 100, 1, 160, 7, 0, 1, 61,
         4, 0, 4, 254, 2, 243, 1, 2, 1, 7, 2, 5, 1, 0, 7, 109, 7, 0, 96, 128, 240, 0,
     ];
+
     #[inline]
     pub fn lookup(c: char) -> bool {
         debug_assert!(!c.is_ascii());
@@ -593,6 +598,7 @@ pub mod n {
         50, 0, 10, 0, 10, 0, 10, 247, 10, 0, 9, 128, 10, 0, 59, 1, 3, 1, 4, 76, 45, 1, 15, 0, 13,
         0, 10, 0,
     ];
+
     #[inline]
     pub fn lookup(c: char) -> bool {
         debug_assert!(!c.is_ascii());
@@ -741,6 +747,7 @@ pub mod white_space {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ];
+
     #[inline]
     pub const fn lookup(c: char) -> bool {
         debug_assert!(!c.is_ascii());
@@ -755,7 +762,7 @@ pub mod white_space {
 }
 
 pub mod conversions {
-    const INDEX_MASK: u32 = 0x400000;
+    const INDEX_MASK: u32 = 1 << 22;
 
     pub fn to_lower(c: char) -> [char; 3] {
         if c.is_ascii() {
@@ -1152,7 +1159,6 @@ pub mod conversions {
         ('\u{1e91d}', 125247), ('\u{1e91e}', 125248), ('\u{1e91f}', 125249), ('\u{1e920}', 125250),
         ('\u{1e921}', 125251),
     ];
-
     #[rustfmt::skip]
     static LOWERCASE_TABLE_MULTI: &[[char; 3]; 1] = &[
         ['i', '\u{307}', '\u{0}'],
@@ -1538,7 +1544,6 @@ pub mod conversions {
         ('\u{1e93d}', 125211), ('\u{1e93e}', 125212), ('\u{1e93f}', 125213), ('\u{1e940}', 125214),
         ('\u{1e941}', 125215), ('\u{1e942}', 125216), ('\u{1e943}', 125217),
     ];
-
     #[rustfmt::skip]
     static UPPERCASE_TABLE_MULTI: &[[char; 3]; 102] = &[
         ['S', 'S', '\u{0}'], ['\u{2bc}', 'N', '\u{0}'], ['J', '\u{30c}', '\u{0}'],

src/tools/unicode-table-generator/src/cascading_map.rs

@@ -1,9 +1,8 @@
 use std::collections::HashMap;
-use std::fmt::Write as _;
 use std::ops::Range;
 
-use crate::fmt_list;
 use crate::raw_emitter::RawEmitter;
+use crate::writeln;
 
 impl RawEmitter {
     pub fn emit_cascading_map(&mut self, ranges: &[Range<u32>]) -> bool {
@@ -24,8 +23,6 @@ impl RawEmitter {
             .flat_map(|r| (r.start..r.end).collect::<Vec<u32>>())
             .collect::<Vec<u32>>();
 
-        println!("there are {} points", points.len());
-
         // how many distinct ranges need to be counted?
         let mut codepoints_by_high_bytes = HashMap::<usize, Vec<u32>>::new();
         for point in points {
@@ -37,41 +34,41 @@ impl RawEmitter {
         }
 
         let mut bit_for_high_byte = 1u8;
-        let mut arms = Vec::<String>::new();
+        let mut arms = String::new();
 
         let mut high_bytes: Vec<usize> = codepoints_by_high_bytes.keys().copied().collect();
         high_bytes.sort();
         for high_byte in high_bytes {
             let codepoints = codepoints_by_high_bytes.get_mut(&high_byte).unwrap();
             if codepoints.len() == 1 {
                 let ch = codepoints.pop().unwrap();
-                arms.push(format!("{high_byte} => c as u32 == {ch:#04x}"));
+                writeln!(arms, "{high_byte} => c as u32 == {ch:#04x},");
                 continue;
             }
             // more than 1 codepoint in this arm
             for codepoint in codepoints {
                 map[(*codepoint & 0xff) as usize] |= bit_for_high_byte;
             }
-            arms.push(format!(
-                "{high_byte} => WHITESPACE_MAP[c as usize & 0xff] & {bit_for_high_byte} != 0"
-            ));
+            writeln!(
+                arms,
+                "{high_byte} => WHITESPACE_MAP[c as usize & 0xff] & {bit_for_high_byte} != 0,"
+            );
             bit_for_high_byte <<= 1;
         }
 
-        writeln!(&mut self.file, "static WHITESPACE_MAP: [u8; 256] = [{}];", fmt_list(map.iter()))
-            .unwrap();
         self.bytes_used += 256;
+        self.file = format!(
+            "static WHITESPACE_MAP: [u8; 256] = {map:?};
 
-        writeln!(&mut self.file, "#[inline]").unwrap();
-        writeln!(&mut self.file, "pub const fn lookup(c: char) -> bool {{").unwrap();
-        writeln!(&mut self.file, "    debug_assert!(!c.is_ascii());").unwrap();
-        writeln!(&mut self.file, "    match c as u32 >> 8 {{").unwrap();
-        for arm in arms {
-            writeln!(&mut self.file, "        {arm},").unwrap();
-        }
-        writeln!(&mut self.file, "        _ => false,").unwrap();
-        writeln!(&mut self.file, "    }}").unwrap();
-        writeln!(&mut self.file, "}}").unwrap();
+            #[inline]
+            pub const fn lookup(c: char) -> bool {{
+                debug_assert!(!c.is_ascii());
+                match c as u32 >> 8 {{
+                    {arms}\
+                    _ => false,
+                }}
+            }}"
+        );
 
         true
     }

src/tools/unicode-table-generator/src/case_mapping.rs

@@ -1,23 +1,18 @@
 use std::char;
 use std::collections::BTreeMap;
-use std::fmt::{self, Write};
 
-use crate::{UnicodeData, fmt_list};
+use crate::{CharEscape, UnicodeData, fmt_list};
 
 const INDEX_MASK: u32 = 1 << 22;
 
 pub(crate) fn generate_case_mapping(data: &UnicodeData) -> (String, [usize; 2]) {
-    let mut file = String::new();
-
-    write!(file, "const INDEX_MASK: u32 = 0x{INDEX_MASK:x};").unwrap();
-    file.push_str("\n\n");
-    file.push_str(HEADER.trim_start());
-    file.push('\n');
     let (lower_tables, lower_size) = generate_tables("LOWER", &data.to_lower);
-    file.push_str(&lower_tables);
-    file.push_str("\n\n");
     let (upper_tables, upper_size) = generate_tables("UPPER", &data.to_upper);
-    file.push_str(&upper_tables);
+    let file = format!(
+        "{HEADER}
+        {lower_tables}
+        {upper_tables}"
+    );
     (file, [lower_size, upper_size])
 }
 
@@ -47,45 +42,23 @@ fn generate_tables(case: &str, data: &BTreeMap<u32, [u32; 3]>) -> (String, usize
         mappings.push((CharEscape(key), value));
     }
 
-    let mut tables = String::new();
-    let mut size = 0;
-
-    size += size_of_val(mappings.as_slice());
-    writeln!(tables, "#[rustfmt::skip]").unwrap();
-    write!(
-        tables,
-        "static {}CASE_TABLE: &[(char, u32); {}] = &[{}];",
-        case,
-        mappings.len(),
-        fmt_list(mappings),
-    )
-    .unwrap();
-
-    tables.push_str("\n\n");
-
-    size += size_of_val(multis.as_slice());
-    writeln!(tables, "#[rustfmt::skip]").unwrap();
-    write!(
-        tables,
-        "static {}CASE_TABLE_MULTI: &[[char; 3]; {}] = &[{}];",
-        case,
-        multis.len(),
-        fmt_list(multis),
-    )
-    .unwrap();
-
-    (tables, size)
-}
-
-struct CharEscape(char);
-
-impl fmt::Debug for CharEscape {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "'{}'", self.0.escape_default())
-    }
+    let size = size_of_val(mappings.as_slice()) + size_of_val(multis.as_slice());
+    let file = format!(
+        "
+    #[rustfmt::skip]\nstatic {case}CASE_TABLE: &[(char, u32); {mappings_len}] = &[{mappings}];
+    #[rustfmt::skip]\nstatic {case}CASE_TABLE_MULTI: &[[char; 3]; {multis_len}] = &[{multis}];",
+        mappings = fmt_list(&mappings),
+        mappings_len = mappings.len(),
+        multis = fmt_list(&multis),
+        multis_len = multis.len(),
+    );
+
+    (file, size)
 }
 
 static HEADER: &str = r"
+const INDEX_MASK: u32 = 1 << 22;
+
 pub fn to_lower(c: char) -> [char; 3] {
     if c.is_ascii() {
         [(c as u8).to_ascii_lowercase() as char, '\0', '\0']

src/tools/unicode-table-generator/src/fmt_helpers.rs

@@ -0,0 +1,66 @@
+use std::fmt;
+
+// Convenience macros for writing and unwrapping.
+#[macro_export]
+macro_rules! writeln {
+    ($($args:tt)*) => {{
+        use std::fmt::Write as _;
+        std::writeln!($($args)*).unwrap();
+    }};
+}
+#[macro_export]
+macro_rules! write {
+    ($($args:tt)*) => {{
+        use std::fmt::Write as _;
+        std::write!($($args)*).unwrap();
+    }};
+}
+
+pub fn fmt_list<V: fmt::Debug>(values: impl IntoIterator<Item = V>) -> String {
+    let pieces = values.into_iter().map(|b| format!("{b:?}, "));
+    let mut out = String::new();
+    let mut line = String::from("\n    ");
+    for piece in pieces {
+        if line.len() + piece.len() < 98 {
+            line.push_str(&piece);
+        } else {
+            writeln!(out, "{}", line.trim_end());
+            line = format!("    {piece}");
+        }
+    }
+    writeln!(out, "{}", line.trim_end());
+    out
+}
+
+/// Wrapper type for formatting a `T` using its `Binary` implementation.
+#[derive(Copy, Clone)]
+pub struct Bin<T>(pub T);
+
+impl<T: fmt::Binary> fmt::Debug for Bin<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let bits = size_of::<T>() * 8;
+        std::write!(f, "0b{:0bits$b}", self.0)
+    }
+}
+
+impl<T: fmt::Binary> fmt::Display for Bin<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
+}
+
+/// Wrapper type for formatting a `char` using `escape_default`.
+#[derive(Copy, Clone)]
+pub struct CharEscape(pub char);
+
+impl fmt::Debug for CharEscape {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        std::write!(f, "'{}'", self.0.escape_default())
+    }
+}
+
+impl fmt::Display for CharEscape {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
+}