diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index 1dbf772842163..9a186f230a3d2 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -838,15 +838,12 @@ impl<'a, 'b> Context<'a, 'b> {
         //
         // But the nested match expression is proved to perform not as well
         // as series of let's; the first approach does.
-        let args_match = {
-            let pat = self.ecx.pat_tuple(self.macsp, pats);
-            let arm = self.ecx.arm(self.macsp, pat, args_array);
-            let head = self.ecx.expr(self.macsp, ast::ExprKind::Tup(heads));
-            self.ecx.expr_match(self.macsp, head, vec![arm])
-        };
+        let pat = self.ecx.pat_tuple(self.macsp, pats);
+        let arm = self.ecx.arm(self.macsp, pat, args_array);
+        let head = self.ecx.expr(self.macsp, ast::ExprKind::Tup(heads));
+        let result = self.ecx.expr_match(self.macsp, head, vec![arm]);
 
-        let ident = Ident::from_str_and_span("args", self.macsp);
-        let args_slice = self.ecx.expr_ident(self.macsp, ident);
+        let args_slice = self.ecx.expr_addr_of(self.macsp, result);
 
         // Now create the fmt::Arguments struct with all our locals we created.
         let (fn_name, fn_args) = if self.all_pieces_simple {
@@ -860,20 +857,14 @@ impl<'a, 'b> Context<'a, 'b> {
         };
 
         let path = self.ecx.std_path(&[sym::fmt, sym::Arguments, Symbol::intern(fn_name)]);
-        let arguments = self.ecx.expr_call_global(self.macsp, path, fn_args);
-        let body = self.ecx.expr_block(P(ast::Block {
-            stmts: vec![self.ecx.stmt_expr(arguments)],
+        let call = self.ecx.expr_call_global(self.macsp, path, fn_args);
+        self.ecx.expr_block(P(ast::Block {
+            stmts: vec![self.ecx.stmt_expr(call)],
             id: ast::DUMMY_NODE_ID,
             rules: BlockCheckMode::Unsafe(UnsafeSource::CompilerGenerated),
             span: self.macsp,
             tokens: None,
-        }));
-
-        let ident = Ident::from_str_and_span("args", self.macsp);
-        let binding_mode = ast::BindingMode::ByRef(ast::Mutability::Not);
-        let pat = self.ecx.pat_ident_binding_mode(self.macsp, ident, binding_mode);
-        let arm = self.ecx.arm(self.macsp, pat, body);
-        self.ecx.expr_match(self.macsp, args_match, vec![arm])
+        }))
     }
 
     fn format_arg(
diff --git a/src/test/pretty/dollar-crate.pp b/src/test/pretty/dollar-crate.pp
index 4eccba06b134f..7df900d80bb84 100644
--- a/src/test/pretty/dollar-crate.pp
+++ b/src/test/pretty/dollar-crate.pp
@@ -10,11 +10,11 @@
 
 fn main() {
     {
-        ::std::io::_print(match match () { () => [], } {
-                              ref args => unsafe {
-                                  ::core::fmt::Arguments::new_v1(&["rust\n"],
-                                                                 args)
-                              }
+        ::std::io::_print(unsafe {
+                              ::core::fmt::Arguments::new_v1(&["rust\n"],
+                                                             &match () {
+                                                                  () => [],
+                                                              })
                           });
     };
 }
diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index a21ea520121e3..cd99f5c84a24d 100644
--- a/src/test/pretty/issue-4264.pp
+++ b/src/test/pretty/issue-4264.pp
@@ -32,38 +32,33 @@
                   ({
                        let res =
                            ((::alloc::fmt::format as
-                                for<'r> fn(Arguments<'r>) -> String {format})((match (match (()
-                                                                                                as
-                                                                                                ())
-                                                                                          {
-                                                                                          ()
-                                                                                          =>
-                                                                                          ([]
-                                                                                              as
-                                                                                              [ArgumentV1; 0]),
-                                                                                      }
-                                                                                         as
-                                                                                         [ArgumentV1; 0])
-                                                                                   {
-                                                                                   ref args
-                                                                                   =>
-                                                                                   unsafe
-                                                                                   {
-                                                                                       ((::core::fmt::Arguments::new_v1
-                                                                                            as
-                                                                                            unsafe fn(&[&'static str], &[ArgumentV1]) -> Arguments {Arguments::new_v1})((&([("test"
-                                                                                                                                                                                as
-                                                                                                                                                                                &str)]
-                                                                                                                                                                              as
-                                                                                                                                                                              [&str; 1])
+                                for<'r> fn(Arguments<'r>) -> String {format})((unsafe
+                                                                               {
+                                                                                   ((::core::fmt::Arguments::new_v1
+                                                                                        as
+                                                                                        unsafe fn(&[&'static str], &[ArgumentV1]) -> Arguments {Arguments::new_v1})((&([("test"
                                                                                                                                                                             as
-                                                                                                                                                                            &[&str; 1]),
-                                                                                                                                                                        (args
-                                                                                                                                                                            as
-                                                                                                                                                                            &[ArgumentV1; 0]))
-                                                                                           as
-                                                                                           Arguments)
-                                                                                   }
+                                                                                                                                                                            &str)]
+                                                                                                                                                                          as
+                                                                                                                                                                          [&str; 1])
+                                                                                                                                                                        as
+                                                                                                                                                                        &[&str; 1]),
+                                                                                                                                                                    (&(match (()
+                                                                                                                                                                                 as
+                                                                                                                                                                                 ())
+                                                                                                                                                                           {
+                                                                                                                                                                           ()
+                                                                                                                                                                           =>
+                                                                                                                                                                           ([]
+                                                                                                                                                                               as
+                                                                                                                                                                               [ArgumentV1; 0]),
+                                                                                                                                                                       }
+                                                                                                                                                                          as
+                                                                                                                                                                          [ArgumentV1; 0])
+                                                                                                                                                                        as
+                                                                                                                                                                        &[ArgumentV1; 0]))
+                                                                                       as
+                                                                                       Arguments)
                                                                                }
                                                                                   as
                                                                                   Arguments))
diff --git a/src/test/ui/attributes/key-value-expansion.stderr b/src/test/ui/attributes/key-value-expansion.stderr
index 03ca515265cb0..20c83f2d286e4 100644
--- a/src/test/ui/attributes/key-value-expansion.stderr
+++ b/src/test/ui/attributes/key-value-expansion.stderr
@@ -17,15 +17,15 @@ LL | bug!();
 
 error: unexpected token: `{
     let res =
-        ::alloc::fmt::format(match match (&"u8",) {
-                                       (arg0,) =>
-                                       [::core::fmt::ArgumentV1::new(arg0,
-                                                                     ::core::fmt::Display::fmt)],
-                                   } {
-                                 ref args => unsafe {
-                                     ::core::fmt::Arguments::new_v1(&[""],
-                                                                    args)
-                                 }
+        ::alloc::fmt::format(unsafe {
+                                 ::core::fmt::Arguments::new_v1(&[""],
+                                                                &match (&"u8",)
+                                                                     {
+                                                                     (arg0,)
+                                                                     =>
+                                                                     [::core::fmt::ArgumentV1::new(arg0,
+                                                                                                   ::core::fmt::Display::fmt)],
+                                                                 })
                              });
     res
 }.as_str()`