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                   (($crate::fmt::format as
  33                        for<'r> fn(std::fmt::Arguments<'r>) -> std::string::String {std::fmt::format})(((<$crate::fmt::Arguments>::new_v1
  34                                                                                                            as
  35                                                                                                            fn(&[&str], &[std::fmt::ArgumentV1<'_>]) -> std::fmt::Arguments<'_> {std::fmt::Arguments::<'_>::new_v1})((&([("test"
  36                                                                                                                                                                                                                             as
  37                                                                                                                                                                                                                             &'static str)]
  38                                                                                                                                                                                                                           as
  39                                                                                                                                                                                                                           [&str; 1])
  40                                                                                                                                                                                                                         as
  41                                                                                                                                                                                                                         &[&str; 1]),
  42                                                                                                                                                                                                                     (&(match (()
  43                                                                                                                                                                                                                                  as
  44                                                                                                                                                                                                                                  ())
  45                                                                                                                                                                                                                            {
  46                                                                                                                                                                                                                            ()
  47                                                                                                                                                                                                                            =>
  48                                                                                                                                                                                                                            ([]
  49                                                                                                                                                                                                                                as
  50                                                                                                                                                                                                                                [std::fmt::ArgumentV1<'_>; 0]),
  51                                                                                                                                                                                                                        }
  52                                                                                                                                                                                                                           as
  53                                                                                                                                                                                                                           [std::fmt::ArgumentV1<'_>; 0])
  54                                                                                                                                                                                                                         as
  55                                                                                                                                                                                                                         &[std::fmt::ArgumentV1<'_>; 0]))
  56                                                                                                           as
  57                                                                                                           std::fmt::Arguments<'_>))
  58                       as std::string::String);
  59               } as ())
  60 pub type Foo = [i32; (3 as usize)];
  61 pub struct Bar {
  62     pub x: [i32; (3 as usize)],
  63 }
  64 pub struct TupleBar([i32; (4 as usize)]);
  65 pub enum Baz { BazVariant([i32; (5 as usize)]), }
  66 pub fn id<T>(x: T) -> T ({ (x as T) } as T)
  67 pub fn use_id() ({
  68                      let _ =
  69                          ((id::<[i32; (3 as usize)]> as
  70                               fn([i32; 3]) -> [i32; 3] {id::<[i32; 3]>})(([(1
  71                                                                                as
  72                                                                                i32),
  73                                                                            (2
  74                                                                                as
  75                                                                                i32),
  76                                                                            (3
  77                                                                                as
  78                                                                                i32)]
  79                                                                              as
  80                                                                              [i32; 3]))
  81                              as [i32; 3]);
  82                  } as ())
  83 fn main() ({ } as ())