From d6689e5d1c2fad418e6f37583ba4946c380deb95 Mon Sep 17 00:00:00 2001
From: Eduard Burtescu <edy.burt@gmail.com>
Date: Fri, 18 Mar 2016 02:22:32 +0200
Subject: [PATCH] Update the not-at-all-pretty pain-o-tron-4000+264 test.

---
 src/test/pretty/issue-4264.pp | 58 +++++++++++++++++------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index 0347631aeb336..fedb68a26afc9 100644
--- a/src/test/pretty/issue-4264.pp
+++ b/src/test/pretty/issue-4264.pp
@@ -41,37 +41,37 @@
     ((::std::fmt::format as
          fn(core::fmt::Arguments<'_>) -> collections::string::String {collections::fmt::format})(((::std::fmt::Arguments::new_v1
                                                                                                       as
-                                                                                                      fn(&[&str], &[core::fmt::ArgumentV1<'_>]) -> core::fmt::Arguments<'_> {core::fmt::Arguments<'a>::new_v1})(({
-                                                                                                                                                                                                                     static __STATIC_FMTSTR:
-                                                                                                                                                                                                                            &'static [&'static str]
-                                                                                                                                                                                                                            =
-                                                                                                                                                                                                                         (&([("test"
+                                                                                                      fn(&[&str], &[core::fmt::ArgumentV1<'_>]) -> core::fmt::Arguments<'_> {core::fmt::Arguments<'a><'_>::new_v1})(({
+                                                                                                                                                                                                                         static __STATIC_FMTSTR:
+                                                                                                                                                                                                                                &'static [&'static str]
+                                                                                                                                                                                                                                =
+                                                                                                                                                                                                                             (&([("test"
+                                                                                                                                                                                                                                     as
+                                                                                                                                                                                                                                     &'static str)]
+                                                                                                                                                                                                                                   as
+                                                                                                                                                                                                                                   [&'static str; 1])
                                                                                                                                                                                                                                  as
-                                                                                                                                                                                                                                 &'static str)]
-                                                                                                                                                                                                                               as
-                                                                                                                                                                                                                               [&'static str; 1])
-                                                                                                                                                                                                                             as
-                                                                                                                                                                                                                             &'static [&'static str; 1]);
-                                                                                                                                                                                                                     (__STATIC_FMTSTR
-                                                                                                                                                                                                                         as
-                                                                                                                                                                                                                         &'static [&'static str])
-                                                                                                                                                                                                                 }
-                                                                                                                                                                                                                    as
-                                                                                                                                                                                                                    &[&str]),
-                                                                                                                                                                                                                (&(match (()
+                                                                                                                                                                                                                                 &'static [&'static str; 1]);
+                                                                                                                                                                                                                         (__STATIC_FMTSTR
                                                                                                                                                                                                                              as
-                                                                                                                                                                                                                             ())
-                                                                                                                                                                                                                       {
-                                                                                                                                                                                                                       ()
-                                                                                                                                                                                                                       =>
-                                                                                                                                                                                                                       ([]
-                                                                                                                                                                                                                           as
-                                                                                                                                                                                                                           [core::fmt::ArgumentV1<'_>; 0]),
-                                                                                                                                                                                                                   }
-                                                                                                                                                                                                                      as
-                                                                                                                                                                                                                      [core::fmt::ArgumentV1<'_>; 0])
-                                                                                                                                                                                                                    as
-                                                                                                                                                                                                                    &[core::fmt::ArgumentV1<'_>; 0]))
+                                                                                                                                                                                                                             &'static [&'static str])
+                                                                                                                                                                                                                     }
+                                                                                                                                                                                                                        as
+                                                                                                                                                                                                                        &[&str]),
+                                                                                                                                                                                                                    (&(match (()
+                                                                                                                                                                                                                                 as
+                                                                                                                                                                                                                                 ())
+                                                                                                                                                                                                                           {
+                                                                                                                                                                                                                           ()
+                                                                                                                                                                                                                           =>
+                                                                                                                                                                                                                           ([]
+                                                                                                                                                                                                                               as
+                                                                                                                                                                                                                               [core::fmt::ArgumentV1<'_>; 0]),
+                                                                                                                                                                                                                       }
+                                                                                                                                                                                                                          as
+                                                                                                                                                                                                                          [core::fmt::ArgumentV1<'_>; 0])
+                                                                                                                                                                                                                        as
+                                                                                                                                                                                                                        &[core::fmt::ArgumentV1<'_>; 0]))
                                                                                                      as
                                                                                                      core::fmt::Arguments<'_>))
         as collections::string::String);