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

@@ -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:#04x} => 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:#04x} => 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/cascading_map.rs

@@ -1,19 +1,18 @@
 use std::char;
 use std::collections::BTreeMap;
-use std::fmt::{self, Write};
 
-use crate::{UnicodeData, fmt_list};
+use crate::fmt_helpers::Hex;
+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();
-
     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!(
+        "{lower_tables}
+        {upper_tables}"
+    );
     (file, [lower_size, upper_size])
 }
 
@@ -43,14 +42,18 @@ fn generate_tables(case: &str, data: &BTreeMap<u32, [u32; 3]>) -> (String, usize
             INDEX_MASK | (u32::try_from(multis.len()).unwrap() - 1)
         };
 
-        mappings.push((CharEscape(key), value));
+        mappings.push((CharEscape(key), Hex(value)));
     }
 
-    let mut size = 0;
-    let mut tables = String::new();
-    writeln!(
-        tables,
-        "\
+    let size = size_of_val(mappings.as_slice()) + size_of_val(multis.as_slice());
+    let file = format!(
+        "
+#[rustfmt::skip]
+static {case}CASE_TABLE: &[(char, u32); {mappings_len}] = &[{mappings}];
+
+#[rustfmt::skip]
+static {case}CASE_TABLE_MULTI: &[[char; 3]; {multis_len}] = &[{multis}];
+
 #[inline]
 pub fn to_{case_lower}(c: char) -> [char; 3] {{
     const {{
@@ -81,40 +84,7 @@ pub fn to_{case_lower}(c: char) -> [char; 3] {{
         mappings_len = mappings.len(),
         multis = fmt_list(&multis),
         multis_len = multis.len(),
-    )
-    .unwrap();
-
-    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())
-    }
+    (file, size)
 }

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

@@ -0,0 +1,82 @@
+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 `T` using its `LowerHex` implementation.
+#[derive(Copy, Clone)]
+pub struct Hex<T>(pub T);
+
+impl<T: fmt::LowerHex> fmt::Debug for Hex<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        std::write!(f, "{:#x}", self.0)
+    }
+}
+
+impl<T: fmt::LowerHex> fmt::Display for Hex<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
+}
+
+/// Wrapper type for formatting a `char` using `escape_unicode`.
+#[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_unicode())
+    }
+}
+
+impl fmt::Display for CharEscape {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
+}