Update fmt::Arguments closure to take dyn Write.

Using a new Formatter for every fmt invocation allows the compiler to
make assumptions about the state of the formatting flags.

Author: m-ou-se

compiler/rustc_builtin_macros/src/format/expand.rs

@@ -22,26 +22,24 @@ pub fn expand_parsed_format_args(ecx: &mut ExtCtxt<'_>, fmt: FormatArgs) -> P<as
     }
 
     let args = Ident::new(sym::_args, macsp);
-    let f = Ident::new(sym::f, macsp);
+    let w = Ident::new(sym::w, macsp);
 
     let arguments = fmt.arguments.into_vec();
 
     let mut statements = Vec::new();
 
-    let mut default_options = true;
-
     for piece in fmt.template {
         match piece {
             FormatArgsPiece::Literal(s) => {
                 // Generate:
-                //     f.write_str("…")?;
+                //     w.write_str("…")?;
                 statements.push(ecx.stmt_expr(ecx.expr(
                     macsp,
                     ast::ExprKind::Try(ecx.expr(
                         macsp,
                         ast::ExprKind::MethodCall(
                             ast::PathSegment::from_ident(Ident::new(sym::write_str, macsp)),
-                            ecx.expr_ident(macsp, f),
+                            ecx.expr_ident(macsp, w),
                             vec![ecx.expr_str(macsp, s)],
                             macsp,
                         ),
@@ -51,16 +49,23 @@ pub fn expand_parsed_format_args(ecx: &mut ExtCtxt<'_>, fmt: FormatArgs) -> P<as
             FormatArgsPiece::Placeholder(p) => {
                 // Don't set options if they're still set to defaults
                 // and this placeholder also uses default options.
-                let d = p.format_options == FormatOptions::default();
-                if !default_options || !d {
-                    default_options = d;
-                    // Generate:
-                    //     f.set_options(…);
-                    statements.push(ecx.stmt_expr(ecx.expr(
+
+                // Generate:
+                //     ::core::fmt::Formatter::new(w)
+                let mut formatter = ecx.expr_call_global(
+                    macsp,
+                    ecx.std_path(&[sym::fmt, sym::Formatter, sym::new]),
+                    vec![ecx.expr_ident(macsp, w)],
+                );
+
+                if p.format_options != FormatOptions::default() {
+                    // Add:
+                    //     .with_options(…)
+                    formatter = ecx.expr(
                         macsp,
                         ast::ExprKind::MethodCall(
-                            ast::PathSegment::from_ident(Ident::new(sym::set_options, macsp)),
-                            ecx.expr_ident(macsp, f),
+                            ast::PathSegment::from_ident(Ident::new(sym::with_options, macsp)),
+                            formatter,
                             vec![
                                 ecx.expr_u32(macsp, p.format_options.flags),
                                 ecx.expr_char(macsp, p.format_options.fill.unwrap_or(' ')),
@@ -90,10 +95,12 @@ pub fn expand_parsed_format_args(ecx: &mut ExtCtxt<'_>, fmt: FormatArgs) -> P<as
                             ],
                             macsp,
                         ),
-                    )));
+                    );
                 }
+
                 // Generate:
-                //     ::core::fmt::Display::fmt(arg.0, f)?;
+                //     ::core::fmt::Display::fmt(arg.0, &mut formatter)?;
+
                 let arg = if let Ok(i) = p.argument.index {
                     ecx.expr_field(
                         arguments[i].expr.span.with_ctxt(macsp.ctxt()),
@@ -119,7 +126,17 @@ pub fn expand_parsed_format_args(ecx: &mut ExtCtxt<'_>, fmt: FormatArgs) -> P<as
                     ast::ExprKind::Try(ecx.expr_call_global(
                         arg.span,
                         ecx.std_path(&[sym::fmt, fmt_trait, sym::fmt]),
-                        vec![arg, ecx.expr_ident(macsp, f)],
+                        vec![
+                            arg,
+                            ecx.expr(
+                                macsp,
+                                ast::ExprKind::AddrOf(
+                                    ast::BorrowKind::Ref,
+                                    ast::Mutability::Mut,
+                                    formatter,
+                                ),
+                            ),
+                        ],
                     )),
                 )));
             }
@@ -131,7 +148,7 @@ pub fn expand_parsed_format_args(ecx: &mut ExtCtxt<'_>, fmt: FormatArgs) -> P<as
     statements.push(ecx.stmt_expr(ecx.expr_ok(macsp, ecx.expr_tuple(macsp, Vec::new()))));
 
     // Generate:
-    //     |f: &mut ::core::fmt::Formatter| -> ::core::fmt::Result {
+    //     |w: &mut dyn ::core::fmt::Write| -> ::core::fmt::Result {
     //         … // statements
     //     }
     let closure = ecx.expr(
@@ -144,18 +161,26 @@ pub fn expand_parsed_format_args(ecx: &mut ExtCtxt<'_>, fmt: FormatArgs) -> P<as
             ecx.fn_decl(
                 vec![ecx.param(
                     macsp,
-                    f,
+                    w,
                     ecx.ty_rptr(
                         macsp,
-                        ecx.ty_path(ecx.path_all(
+                        ecx.ty(
                             macsp,
-                            true,
-                            ecx.std_path(&[sym::fmt, sym::Formatter]),
-                            vec![ast::GenericArg::Lifetime(ast::Lifetime {
-                                id: ast::DUMMY_NODE_ID,
-                                ident: Ident::new(kw::UnderscoreLifetime, macsp),
-                            })],
-                        )),
+                            ast::TyKind::TraitObject(
+                                vec![ast::GenericBound::Trait(
+                                    ast::PolyTraitRef::new(
+                                        vec![],
+                                        ecx.path_global(
+                                            macsp,
+                                            ecx.std_path(&[sym::fmt, sym::Write]),
+                                        ),
+                                        macsp,
+                                    ),
+                                    ast::TraitBoundModifier::None,
+                                )],
+                                ast::TraitObjectSyntax::Dyn,
+                            ),
+                        ),
                         None,
                         ast::Mutability::Mut,
                     ),

compiler/rustc_span/src/symbol.rs

@@ -308,6 +308,7 @@ symbols! {
         Vec,
         VecDeque,
         Wrapper,
+        Write,
         Yield,
         _DECLS,
         _Self,
@@ -1325,7 +1326,6 @@ symbols! {
         self_in_typedefs,
         self_struct_ctor,
         semitransparent,
-        set_options,
         shadow_call_stack,
         shl,
         shl_assign,
@@ -1620,6 +1620,7 @@ symbols! {
         vreg_low16,
         vtable_align,
         vtable_size,
+        w,
         warn,
         wasm_abi,
         wasm_import_module,
@@ -1629,6 +1630,7 @@ symbols! {
         windows,
         windows_subsystem,
         with_negative_coherence,
+        with_options,
         wrapping_add,
         wrapping_mul,
         wrapping_sub,

library/core/src/fmt/mod.rs

@@ -261,19 +261,20 @@ impl<'a> Formatter<'a> {
     #[unstable(feature = "fmt_internals", issue = "none")]
     #[doc(hidden)]
     #[inline]
-    pub fn set_options(
-        &mut self,
+    pub fn with_options(
+        mut self,
         flags: u32,
         fill: char,
         align: rt::v1::Alignment,
         width: Option<usize>,
         precision: Option<usize>,
-    ) {
+    ) -> Self {
         self.flags = flags;
         self.fill = fill;
         self.align = align;
         self.width = width;
         self.precision = precision;
+        self
     }
 }
 
@@ -460,7 +461,7 @@ impl<'a> Arguments<'a> {
     #[unstable(feature = "fmt_internals", reason = "internal to format_args!", issue = "none")]
     #[rustc_const_unstable(feature = "const_fmt_arguments_new", issue = "none")]
     #[cfg(not(bootstrap))]
-    pub const fn new(f: &'a dyn Fn(&mut Formatter<'_>) -> Result) -> Arguments<'a> {
+    pub const fn new(f: &'a dyn Fn(&mut dyn Write) -> Result) -> Arguments<'a> {
         Arguments { inner: Inner::Fn(f) }
     }
 
@@ -545,7 +546,7 @@ pub struct Arguments<'a> {
 #[cfg(not(bootstrap))]
 #[derive(Copy, Clone)]
 enum Inner<'a> {
-    Fn(&'a dyn Fn(&mut Formatter<'_>) -> Result),
+    Fn(&'a dyn Fn(&mut dyn Write) -> Result),
     StaticStr(&'static str),
 }
 
@@ -1286,7 +1287,7 @@ pub trait UpperExp {
 #[inline]
 pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result {
     match args.inner {
-        Inner::Fn(f) => f(&mut Formatter::new(output)),
+        Inner::Fn(f) => f(output),
         Inner::StaticStr(s) => output.write_str(s),
     }
 }

library/std/src/io/stdio.rs

@@ -1026,6 +1026,7 @@ where
 )]
 #[doc(hidden)]
 #[cfg(not(test))]
+#[inline]
 pub fn _print(args: fmt::Arguments<'_>) {
     print_to(args, stdout, "stdout");
 }
@@ -1037,6 +1038,7 @@ pub fn _print(args: fmt::Arguments<'_>) {
 )]
 #[doc(hidden)]
 #[cfg(not(test))]
+#[inline]
 pub fn _eprint(args: fmt::Arguments<'_>) {
     print_to(args, stderr, "stderr");
 }