Imported Upstream version 1.9.0+dfsg1

[rustc.git] / src / test / pretty / issue-4264.pp

diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index 835f7fc96c63fb5e9c6ef6976b32a63daab8a945..6ce534d52b88356d119869bf537b41bc7b266410 100644 (file)
--- a/src/test/pretty/issue-4264.pp
+++ b/src/test/pretty/issue-4264.pp
@@ -39,42 +39,42 @@ pub fn bar() {
 
 
     ((::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"
-                                                                                                                                                                                                                                 as
-                                                                                                                                                                                                                                 &'static str)]
-                                                                                                                                                                                                                               as
-                                                                                                                                                                                                                               [&'static str; 1])
-                                                                                                                                                                                                                             as
-                                                                                                                                                                                                                             &'static [&'static str; 1]);
-                                                                                                                                                                                                                     (__STATIC_FMTSTR
-                                                                                                                                                                                                                         as
-                                                                                                                                                                                                                         &'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);
+         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);
 }
 pub type Foo = [i32; (3 as usize)];
 pub struct Bar {
@@ -86,8 +86,10 @@ 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})(([(1 as i32), (2 as i32),
-                                              (3 as i32)] as [i32; 3])) 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() { }