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(Arguments<'r>) -> String {format})(((::core::fmt::Arguments::new_v1
  36                                                                                    as
  37                                                                                    fn(&[&'static str], &[ArgumentV1]) -> Arguments {Arguments::new_v1})((&([("test"
  38                                                                                                                                                                 as
  39                                                                                                                                                                 &str)]
  40                                                                                                                                                               as
  41                                                                                                                                                               [&str; 1])
  42                                                                                                                                                             as
  43                                                                                                                                                             &[&str; 1]),
  44                                                                                                                                                         (&(match (()
  45                                                                                                                                                                      as
  46                                                                                                                                                                      ())
  47                                                                                                                                                                {
  48                                                                                                                                                                ()
  49                                                                                                                                                                =>
  50                                                                                                                                                                ([]
  51                                                                                                                                                                    as
  52                                                                                                                                                                    [ArgumentV1; 0]),
  53                                                                                                                                                            }
  54                                                                                                                                                               as
  55                                                                                                                                                               [ArgumentV1; 0])
  56                                                                                                                                                             as
  57                                                                                                                                                             &[ArgumentV1; 0]))
  58                                                                                   as
  59                                                                                   Arguments))
  60                                as String);
  61                        (res as String)
  62                    } as 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 ())