Compile format_args! to a closure instead of list of pieces.

Idea stolen from rust-lang/rust#101568

Author: Nemo157

core/src/arguments.rs

@@ -1,62 +1,44 @@
-use crate::{formatter::FormatterArgs, Display, Formatter, Result, StyleDiff};
+use crate::{Display, Formatter, Result};
 
-type StdFmtFn<'a> = dyn Fn(&mut core::fmt::Formatter<'_>) -> Result + 'a;
-
-#[doc(hidden)] // workaround https://github.com/rust-lang/rust/issues/85522
-pub struct StdFmt<'a>(stack_dst::ValueA<StdFmtFn<'a>, [usize; 3]>);
-
-impl<'a> StdFmt<'a> {
-    #[doc(hidden)] // workaround https://github.com/rust-lang/rust/issues/85526
-    pub fn new(f: impl Fn(&mut core::fmt::Formatter<'_>) -> Result + 'a) -> StdFmt<'a> {
-        // not possible(/easy) to correctly type the closure, but with the cast
-        // inference works
-        #[allow(trivial_casts)]
-        StdFmt(
-            stack_dst::ValueA::new_stable(f, |p| p as _)
-                .map_err(|_| ())
-                .expect("StdFmt was more than 3 words, this is a bug in stylish-core"),
-        )
-    }
+#[doc(hidden)]
+/// pub for macros
+pub struct StdFmt<'a> {
+    #[doc(hidden)]
+    /// pub for macros
+    pub f: &'a (dyn Fn(&mut core::fmt::Formatter<'_>) -> Result + 'a),
 }
 
 impl core::fmt::Display for StdFmt<'_> {
+    #[inline]
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result {
-        (self.0)(f)
+        (self.f)(f)
     }
 }
 
 impl core::fmt::Debug for StdFmt<'_> {
+    #[inline]
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result {
-        (self.0)(f)
+        (self.f)(f)
     }
 }
 
-#[doc(hidden)] // workaround https://github.com/rust-lang/rust/issues/85522
+#[doc(hidden)]
 #[allow(missing_debug_implementations)]
-pub enum FormatTrait<'a> {
-    Display(StdFmt<'a>),
-    Debug(StdFmt<'a>),
-    Octal(StdFmt<'a>),
-    LowerHex(StdFmt<'a>),
-    UpperHex(StdFmt<'a>),
-    Pointer(StdFmt<'a>),
-    Binary(StdFmt<'a>),
-    LowerExp(StdFmt<'a>),
-    UpperExp(StdFmt<'a>),
-    Stylish(&'a dyn Display),
-}
+/// pub for macros
+pub struct StdFmtOther<'a>(
+    #[doc(hidden)]
+    /// pub for macros
+    pub StdFmt<'a>,
+);
 
-#[doc(hidden)] // workaround https://github.com/rust-lang/rust/issues/85522
+#[doc(hidden)]
 #[allow(missing_debug_implementations)]
-pub enum Argument<'a> {
-    Lit(&'a str),
-
-    Arg {
-        args: &'a FormatterArgs<'a>,
-        style: StyleDiff,
-        arg: FormatTrait<'a>,
-    },
-}
+/// pub for macros
+pub struct StdFmtDebug<'a>(
+    #[doc(hidden)]
+    /// pub for macros
+    pub StdFmt<'a>,
+);
 
 /// A precompiled version of a format string and its by-reference arguments.
 ///
@@ -72,37 +54,30 @@ pub enum Argument<'a> {
 /// ```
 #[allow(missing_debug_implementations)]
 pub struct Arguments<'a> {
-    #[doc(hidden)] // pub for macros
-    pub pieces: &'a [Argument<'a>],
+    #[doc(hidden)]
+    /// pub for macros
+    pub f: &'a (dyn Fn(&mut Formatter<'_>) -> Result + 'a),
+}
+
+impl Display for StdFmtOther<'_> {
+    #[inline]
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        let arg = &self.0;
+        std_write!(f, Other, arg)
+    }
 }
 
-impl Display for FormatTrait<'_> {
+impl Display for StdFmtDebug<'_> {
+    #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        match self {
-            Self::Display(arg) => std_write!(f, Display, arg),
-            Self::Debug(arg) => std_write!(f, Debug, arg),
-            Self::Octal(arg) => std_write!(f, Display, arg),
-            Self::LowerHex(arg) => std_write!(f, Display, arg),
-            Self::UpperHex(arg) => std_write!(f, Display, arg),
-            Self::Pointer(arg) => std_write!(f, Display, arg),
-            Self::Binary(arg) => std_write!(f, Display, arg),
-            Self::LowerExp(arg) => std_write!(f, Display, arg),
-            Self::UpperExp(arg) => std_write!(f, Display, arg),
-            Self::Stylish(arg) => arg.fmt(f),
-        }
+        let arg = &self.0;
+        std_write!(f, Debug, arg)
     }
 }
 
 impl Display for Arguments<'_> {
+    #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        for piece in self.pieces {
-            match piece {
-                Argument::Lit(lit) => f.write_str(lit)?,
-                Argument::Arg { args, style, arg } => {
-                    arg.fmt(&mut f.with(style).with_args(args))?
-                }
-            }
-        }
-        Ok(())
+        (self.f)(f)
     }
 }

core/src/format.rs

@@ -54,6 +54,7 @@ macro_rules! format {
 ///     "Hello, <span style=color:green>world</span>!"
 /// );
 /// ```
+#[inline]
 pub fn format(args: Arguments<'_>) -> String {
     let mut output = String::new();
     output

core/src/formatter.rs

@@ -48,6 +48,7 @@ pub struct Formatter<'a> {
 }
 
 impl core::fmt::Debug for Formatter<'_> {
+    #[inline]
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result {
         f.debug_struct("Formatter")
             .field("style", &self.style)
@@ -57,6 +58,7 @@ impl core::fmt::Debug for Formatter<'_> {
 }
 
 impl<'a> Formatter<'a> {
+    #[inline]
     pub(crate) fn new(write: &'a mut (dyn Write + 'a)) -> Self {
         Self {
             style: Style::default(),
@@ -99,11 +101,17 @@ impl<'a> Formatter<'a> {
         }
     }
 
-    pub(crate) fn with_args<'b>(&'b mut self, format: &FormatterArgs<'b>) -> Formatter<'b> {
+    #[doc(hidden)]
+    /// pub for macros
+    pub fn with_args<'b>(
+        &'b mut self,
+        format: &FormatterArgs<'b>,
+        restyle: impl Restyle,
+    ) -> Formatter<'b> {
         Formatter {
             write: &mut *self.write,
             format: *format,
-            style: self.style,
+            style: self.style.with(restyle),
         }
     }
 
@@ -130,6 +138,7 @@ impl<'a> Formatter<'a> {
     ///     "Hello <span style=color:red>Ferris</span> and <span style=color:cyan>Gorris</span>"
     /// );
     /// ```
+    #[inline]
     pub fn write_str(&mut self, s: &str) -> Result {
         self.write.write_str(s, self.style)?;
         Ok(())
@@ -157,23 +166,27 @@ impl<'a> Formatter<'a> {
     ///     "Hello <span style=color:red>Ferris</span> and <span style=color:cyan>Gorris</span>"
     /// );
     /// ```
+    #[inline]
     pub fn write_fmt(&mut self, args: Arguments<'_>) -> Result {
         args.fmt(self)?;
         Ok(())
     }
 }
 
 impl<'a> Write for Formatter<'a> {
+    #[inline]
     fn write_str(&mut self, s: &str, style: Style) -> Result {
         self.with(style).write_str(s)
     }
 
+    #[inline]
     fn write_fmt(&mut self, args: Arguments<'_>) -> Result {
         self.write_fmt(args)
     }
 }
 
 impl<'a> core::fmt::Write for Formatter<'a> {
+    #[inline]
     fn write_str(&mut self, s: &str) -> Result {
         self.write_str(s)
     }

core/src/io.rs

@@ -214,6 +214,7 @@ pub trait Write {
     /// output.write_fmt(stylish::format_args!("{:(fg=red)}", '☎'))?;
     /// # Ok::<(), std::io::Error>(())
     /// ```
+    #[inline]
     fn write_fmt(&mut self, args: Arguments<'_>) -> Result<()> {
         let mut trap = ErrorTrap::new(self);
 
@@ -241,6 +242,7 @@ pub trait Write {
     /// )?;
     /// # Ok::<(), std::io::Error>(())
     /// ```
+    #[inline]
     fn by_ref(&mut self) -> &mut Self
     where
         Self: Sized,

core/src/lib.rs

@@ -54,8 +54,8 @@ pub mod 𓀄 {
     pub use with_builtin_macros::with_builtin;
 
     pub use crate::{
-        arguments::{Argument, Arguments, FormatTrait, StdFmt},
-        formatter::{Align, DebugHex, FormatterArgs, Sign},
+        arguments::{Arguments, StdFmt, StdFmtDebug, StdFmtOther},
+        formatter::{Align, DebugHex, Formatter, FormatterArgs, Sign},
         Background, Color, Display, Foreground, Intensity, StyleDiff,
     };
 }

core/src/std_compat.rs

@@ -55,37 +55,20 @@ macro_rules! std_write {
         })
     };
 
-    (@str $f:ident $val:ident [Display $($flag:ident)*]) => {
+    // For most traits we can pipe them through `Display` since they have the same function
+    // signature
+    (@str $f:ident $val:ident [Other $($flag:ident)*]) => {
         std_write!(@str $f $val [$($flag)*] { { debug_hex: _, } => (("",),); })
     };
+
+    // But `Debug` is special as it has extra hex flags
     (@str $f:ident $val:ident [Debug $($flag:ident)*]) => {
         std_write!(@str $f $val [$($flag)*] {
             { debug_hex: None, } => (("?",),);
             { debug_hex: Some(crate::formatter::DebugHex::Lower), } => (("x?",),);
             { debug_hex: Some(crate::formatter::DebugHex::Upper), } => (("X?",),);
         })
     };
-    (@str $f:ident $val:ident [Octal $($flag:ident)*]) => {
-        std_write!(@str $f $val [$($flag)*] { { debug_hex: _, } => (("o",),); })
-    };
-    (@str $f:ident $val:ident [LowerHex $($flag:ident)*]) => {
-        std_write!(@str $f $val [$($flag)*] { { debug_hex: _, } => (("x",),); })
-    };
-    (@str $f:ident $val:ident [UpperHex $($flag:ident)*]) => {
-        std_write!(@str $f $val [$($flag)*] { { debug_hex: _, } => (("X",),); })
-    };
-    (@str $f:ident $val:ident [Pointer $($flag:ident)*]) => {
-        std_write!(@str $f $val [$($flag)*] { { debug_hex: _, } => (("p",),); })
-    };
-    (@str $f:ident $val:ident [Binary $($flag:ident)*]) => {
-        std_write!(@str $f $val [$($flag)*] { { debug_hex: _, } => (("b",),); })
-    };
-    (@str $f:ident $val:ident [LowerExp $($flag:ident)*]) => {
-        std_write!(@str $f $val [$($flag)*] { { debug_hex: _, } => (("e",),); })
-    };
-    (@str $f:ident $val:ident [UpperExp $($flag:ident)*]) => {
-        std_write!(@str $f $val [$($flag)*] { { debug_hex: _, } => (("E",),); })
-    };
 
     ($f:ident, $trait:ident, $val:ident) => {
         std_write!(@str $f $val [$trait precision width zero alternate sign align])

core/src/string.rs

@@ -51,12 +51,14 @@ impl String {
     /// ```rust
     /// assert_eq!(stylish::html::format!("{:s}", stylish::String::new()), "");
     /// ```
+    #[inline]
     pub fn new() -> Self {
         Self::default()
     }
 }
 
 impl Write for String {
+    #[inline]
     fn write_str(&mut self, s: &str, style: Style) -> Result {
         if Some(style) != self.styles.last().map(|&(_, style)| style) {
             self.styles.push((self.string.len(), style));
@@ -67,6 +69,7 @@ impl Write for String {
 }
 
 impl Display for String {
+    #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         let mut styles = self.styles.iter().peekable();
         while let Some(&(start, style)) = styles.next() {

core/src/write.rs

@@ -64,6 +64,7 @@ pub trait Write {
     /// );
     /// # Ok::<(), core::fmt::Error>(())
     /// ```
+    #[inline]
     fn write_char(&mut self, c: char, style: Style) -> Result {
         self.write_str(c.encode_utf8(&mut [0; 4]), style)
     }
@@ -85,6 +86,7 @@ pub trait Write {
     /// assert_eq!(s, "<span style=color:red>☎</span>");
     /// # Ok::<(), core::fmt::Error>(())
     /// ```
+    #[inline]
     fn write_fmt(mut self: &mut Self, args: Arguments<'_>) -> Result {
         Formatter::new(&mut self).write_fmt(args)
     }