src/test/pretty/issue-4264.pp

   1 #[prelude_import]
   2 use ::std::prelude::rust_2015::*;
   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})((match (match (()
  36                                                                                                 as
  37                                                                                                 ())
  38                                                                                           {
  39                                                                                           ()
  40                                                                                           =>
  41                                                                                           ([]
  42                                                                                               as
  43                                                                                               [ArgumentV1; 0]),
  44                                                                                       }
  45                                                                                          as
  46                                                                                          [ArgumentV1; 0])
  47                                                                                    {
  48                                                                                    ref args
  49                                                                                    =>
  50                                                                                    unsafe
  51                                                                                    {
  52                                                                                        ((::core::fmt::Arguments::new_v1
  53                                                                                             as
  54                                                                                             unsafe fn(&[&'static str], &[ArgumentV1]) -> Arguments {Arguments::new_v1})((&([("test"
  55                                                                                                                                                                                 as
  56                                                                                                                                                                                 &str)]
  57                                                                                                                                                                               as
  58                                                                                                                                                                               [&str; 1])
  59                                                                                                                                                                             as
  60                                                                                                                                                                             &[&str; 1]),
  61                                                                                                                                                                         (args
  62                                                                                                                                                                             as
  63                                                                                                                                                                             &[ArgumentV1; 0]))
  64                                                                                            as
  65                                                                                            Arguments)
  66                                                                                    }
  67                                                                                }
  68                                                                                   as
  69                                                                                   Arguments))
  70                                as String);
  71                        (res as String)
  72                    } as String);
  73               } as ())
  74 pub type Foo = [i32; (3 as usize)];
  75 pub struct Bar {
  76     pub x: [i32; (3 as usize)],
  77 }
  78 pub struct TupleBar([i32; (4 as usize)]);
  79 pub enum Baz { BazVariant([i32; (5 as usize)]), }
  80 pub fn id<T>(x: T) -> T ({ (x as T) } as T)
  81 pub fn use_id() ({
  82                      let _ =
  83                          ((id::<[i32; (3 as usize)]> as
  84                               fn([i32; 3]) -> [i32; 3] {id::<[i32; 3]>})(([(1
  85                                                                                as
  86                                                                                i32),
  87                                                                            (2
  88                                                                                as
  89                                                                                i32),
  90                                                                            (3
  91                                                                                as
  92                                                                                i32)]
  93                                                                              as
  94                                                                              [i32; 3]))
  95                              as [i32; 3]);
  96                  } as ())
  97 fn main() ({ } as ())