src/test/pretty/issue-4264.pp

   1 #[prelude_import]
   2 use ::std::prelude::v1::*;
   3 #[macro_use]
   4 extern crate std;
   5 // pretty-compare-only
   6 // pretty-mode:hir,typed
   7 // pp-exact:issue-4264.pp
   8
   9 // #4264 fixed-length vector types
  10
  11 pub fn foo(_: [i32; (3 as usize)]) ({ } as ())
  12
  13 pub fn bar() ({
  14                   const FOO: usize = ((5 as usize) - (4 as usize) as usize);
  15                   let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]);
  16
  17                   let _: [(); (1 as usize)] = ([(() as ())] as [(); 1]);
  18
  19                   let _ =
  20                       (((&([(1 as i32), (2 as i32), (3 as i32)] as [i32; 3])
  21                             as &[i32; 3]) as *const _ as *const [i32; 3]) as
  22                           *const [i32; (3 as usize)] as *const [i32; 3]);
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32                   ({
  33                        let res =
  34                            ((::alloc::fmt::format as
  35                                 for<'r> fn(std::fmt::Arguments<'r>) -> std::string::String {std::fmt::format})(((::core::fmt::Arguments::new_v1
  36                                                                                                                     as
  37                                                                                                                     fn(&[&str], &[std::fmt::ArgumentV1<'_>]) -> std::fmt::Arguments<'_> {std::fmt::Arguments::<'_>::new_v1})((&([("test"
  38                                                                                                                                                                                                                                      as
  39                                                                                                                                                                                                                                      &'static str)]
  40                                                                                                                                                                                                                                    as
  41                                                                                                                                                                                                                                    [&str; 1])
  42                                                                                                                                                                                                                                  as
  43                                                                                                                                                                                                                                  &[&str; 1]),
  44                                                                                                                                                                                                                              (&(match (()
  45                                                                                                                                                                                                                                           as
  46                                                                                                                                                                                                                                           ())
  47                                                                                                                                                                                                                                     {
  48                                                                                                                                                                                                                                     ()
  49                                                                                                                                                                                                                                     =>
  50                                                                                                                                                                                                                                     ([]
  51                                                                                                                                                                                                                                         as
  52                                                                                                                                                                                                                                         [std::fmt::ArgumentV1<'_>; 0]),
  53                                                                                                                                                                                                                                 }
  54                                                                                                                                                                                                                                    as
  55                                                                                                                                                                                                                                    [std::fmt::ArgumentV1<'_>; 0])
  56                                                                                                                                                                                                                                  as
  57                                                                                                                                                                                                                                  &[std::fmt::ArgumentV1<'_>; 0]))
  58                                                                                                                    as
  59                                                                                                                    std::fmt::Arguments<'_>))
  60                                as std::string::String);
  61                        (res as std::string::String)
  62                    } as std::string::String);
  63               } as ())
  64 pub type Foo = [i32; (3 as usize)];
  65 pub struct Bar {
  66     pub x: [i32; (3 as usize)],
  67 }
  68 pub struct TupleBar([i32; (4 as usize)]);
  69 pub enum Baz { BazVariant([i32; (5 as usize)]), }
  70 pub fn id<T>(x: T) -> T ({ (x as T) } as T)
  71 pub fn use_id() ({
  72                      let _ =
  73                          ((id::<[i32; (3 as usize)]> as
  74                               fn([i32; 3]) -> [i32; 3] {id::<[i32; 3]>})(([(1
  75                                                                                as
  76                                                                                i32),
  77                                                                            (2
  78                                                                                as
  79                                                                                i32),
  80                                                                            (3
  81                                                                                as
  82                                                                                i32)]
  83                                                                              as
  84                                                                              [i32; 3]))
  85                              as [i32; 3]);
  86                  } as ())
  87 fn main() ({ } as ())