tests: fix fallout in pretty-printing output exact-match tests.

diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index 40ff4852e3856b159f273819fc107cff3b7c139d..24b0f90d08e4d21cc56bf8c2e15e4ea142e8ce25 100644 (file)
--- a/src/test/pretty/issue-4264.pp
+++ b/src/test/pretty/issue-4264.pp
@@ -18,18 +18,18 @@ extern crate std as std;
 
 // #4264 fixed-length vector types
 
-pub fn foo(_: [i32; (3 as usize)]) { }
+pub fn foo(_: [i32; (3 as usize)]) ({ } as ())
 
-pub fn bar() {
-    const FOO: usize = ((5 as usize) - (4 as usize) as usize);
-    let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]);
+pub fn bar() ({
+                  const FOO: usize = ((5 as usize) - (4 as usize) as usize);
+                  let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]);
 
-    let _: [(); (1 as usize)] = ([(() as ())] as [(); 1]);
+                  let _: [(); (1 as usize)] = ([(() as ())] as [(); 1]);
 
-    let _ =
-        (((&([(1 as i32), (2 as i32), (3 as i32)] as [i32; 3]) as &[i32; 3])
-             as *const _ as *const [i32; 3]) as *const [i32; (3 as usize)] as
-            *const [i32; 3]);
+                  let _ =
+                      (((&([(1 as i32), (2 as i32), (3 as i32)] as [i32; 3])
+                            as &[i32; 3]) as *const _ as *const [i32; 3]) as
+                          *const [i32; (3 as usize)] as *const [i32; 3]);
 
 
 
@@ -38,58 +38,66 @@ pub fn bar() {
 
 
 
-    (($crate::fmt::format as
-         fn(std::fmt::Arguments<'_>) -> std::string::String {std::fmt::format})(((::std::fmt::Arguments::new_v1
-                                                                                     as
-                                                                                     fn(&[&str], &[std::fmt::ArgumentV1<'_>]) -> std::fmt::Arguments<'_> {std::fmt::Arguments<'_>::new_v1})(({
-                                                                                                                                                                                                 static __STATIC_FMTSTR:
-                                                                                                                                                                                                        &'static [&'static str]
-                                                                                                                                                                                                        =
-                                                                                                                                                                                                     (&([("test"
-                                                                                                                                                                                                             as
-                                                                                                                                                                                                             &'static str)]
-                                                                                                                                                                                                           as
-                                                                                                                                                                                                           [&'static str; 1])
-                                                                                                                                                                                                         as
-                                                                                                                                                                                                         &'static [&'static str; 1]);
-                                                                                                                                                                                                 (__STATIC_FMTSTR
-                                                                                                                                                                                                     as
-                                                                                                                                                                                                     &'static [&'static str])
-                                                                                                                                                                                             }
-                                                                                                                                                                                                as
-                                                                                                                                                                                                &[&str]),
-                                                                                                                                                                                            (&(match (()
-                                                                                                                                                                                                         as
-                                                                                                                                                                                                         ())
-                                                                                                                                                                                                   {
-                                                                                                                                                                                                   ()
-                                                                                                                                                                                                   =>
-                                                                                                                                                                                                   ([]
-                                                                                                                                                                                                       as
-                                                                                                                                                                                                       [std::fmt::ArgumentV1<'_>; 0]),
-                                                                                                                                                                                               }
-                                                                                                                                                                                                  as
-                                                                                                                                                                                                  [std::fmt::ArgumentV1<'_>; 0])
-                                                                                                                                                                                                as
-                                                                                                                                                                                                &[std::fmt::ArgumentV1<'_>; 0]))
-                                                                                    as
-                                                                                    std::fmt::Arguments<'_>))
-        as std::string::String);
-}
+
+                  (($crate::fmt::format as
+                       fn(std::fmt::Arguments<'_>) -> std::string::String {std::fmt::format})(((::std::fmt::Arguments::new_v1
+                                                                                                   as
+                                                                                                   fn(&[&str], &[std::fmt::ArgumentV1<'_>]) -> std::fmt::Arguments<'_> {std::fmt::Arguments<'_>::new_v1})(({
+                                                                                                                                                                                                               static __STATIC_FMTSTR:
+                                                                                                                                                                                                                      &'static [&'static str]
+                                                                                                                                                                                                                      =
+                                                                                                                                                                                                                   (&([("test"
+                                                                                                                                                                                                                           as
+                                                                                                                                                                                                                           &'static str)]
+                                                                                                                                                                                                                         as
+                                                                                                                                                                                                                         [&'static str; 1])
+                                                                                                                                                                                                                       as
+                                                                                                                                                                                                                       &'static [&'static str; 1]);
+                                                                                                                                                                                                               (__STATIC_FMTSTR
+                                                                                                                                                                                                                   as
+                                                                                                                                                                                                                   &'static [&'static str])
+                                                                                                                                                                                                           }
+                                                                                                                                                                                                              as
+                                                                                                                                                                                                              &[&str]),
+                                                                                                                                                                                                          (&(match (()
+                                                                                                                                                                                                                       as
+                                                                                                                                                                                                                       ())
+                                                                                                                                                                                                                 {
+                                                                                                                                                                                                                 ()
+                                                                                                                                                                                                                 =>
+                                                                                                                                                                                                                 ([]
+                                                                                                                                                                                                                     as
+                                                                                                                                                                                                                     [std::fmt::ArgumentV1<'_>; 0]),
+                                                                                                                                                                                                             }
+                                                                                                                                                                                                                as
+                                                                                                                                                                                                                [std::fmt::ArgumentV1<'_>; 0])
+                                                                                                                                                                                                              as
+                                                                                                                                                                                                              &[std::fmt::ArgumentV1<'_>; 0]))
+                                                                                                  as
+                                                                                                  std::fmt::Arguments<'_>))
+                      as std::string::String);
+              } as ())
 pub type Foo = [i32; (3 as usize)];
 pub struct Bar {
     pub x: [i32; (3 as usize)],
 }
 pub struct TupleBar([i32; (4 as usize)]);
 pub enum Baz { BazVariant([i32; (5 as usize)]), }
-pub fn id<T>(x: T) -> T { (x as T) }
-pub fn use_id() {
-    let _ =
-        ((id::<[i32; (3 as usize)]> as
-             fn([i32; 3]) -> [i32; 3] {id::<[i32; 3]>})(([(1 as i32),
-                                                          (2 as i32),
-                                                          (3 as i32)] as
-                                                            [i32; 3])) as
-            [i32; 3]);
-}
-fn main() { }
+pub fn id<T>(x: T) -> T ({ (x as T) } as T)
+pub fn use_id() ({
+                     let _ =
+                         ((id::<[i32; (3 as usize)]> as
+                              fn([i32; 3]) -> [i32; 3] {id::<[i32; 3]>})(([(1
+                                                                               as
+                                                                               i32),
+                                                                           (2
+                                                                               as
+                                                                               i32),
+                                                                           (3
+                                                                               as
+                                                                               i32)]
+                                                                             as
+                                                                             [i32; 3]))
+                             as [i32; 3]);
+                 } as ())
+fn main() ({ } as ())

diff --git a/src/test/pretty/stmt_expr_attributes.rs b/src/test/pretty/stmt_expr_attributes.rs
index e52932cd7befa32bd391ea2f8bb0b7dd5006b762..1c443020d2e934970fef26d77a8b57fb318bdd82 100644 (file)
--- a/src/test/pretty/stmt_expr_attributes.rs
+++ b/src/test/pretty/stmt_expr_attributes.rs
@@ -198,14 +198,20 @@ fn _11() {
                 };
     let _ = #[attr] || #[attr] ();
     let _ = #[attr] move || #[attr] ();
-    let _ = #[attr] || {
-        #![attr]
-        #[attr]
-        () };
-    let _ = #[attr] move || {
-        #![attr]
-        #[attr]
-        () };
+    let _ =
+        #[attr] ||
+                    {
+                        #![attr]
+                        #[attr]
+                        ()
+                    };
+    let _ =
+        #[attr] move ||
+                    {
+                        #![attr]
+                        #[attr]
+                        ()
+                    };
     let _ =
         #[attr] {
                     #![attr]