src/test/pretty/issue-4264.pp

   1 #[prelude_import]
   2 use std::prelude::v1::*;
   3 #[macro_use]
   4 extern crate std as std;
   5 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   6 // file at the top-level directory of this distribution and at
   7 // http://rust-lang.org/COPYRIGHT.
   8 //
   9 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
  10 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
  11 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
  12 // option. This file may not be copied, modified, or distributed
  13 // except according to those terms.
  14
  15 // pretty-compare-only
  16 // pretty-mode:hir,typed
  17 // pp-exact:issue-4264.pp
  18
  19 // #4264 fixed-length vector types
  20
  21 pub fn foo(_: [i32; (3 as usize)]) ({ } as ())
  22
  23 pub fn bar() ({
  24                   const FOO: usize = ((5 as usize) - (4 as usize) as usize);
  25                   let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]);
  26
  27                   let _: [(); (1 as usize)] = ([(() as ())] as [(); 1]);
  28
  29                   let _ =
  30                       (((&([(1 as i32), (2 as i32), (3 as i32)] as [i32; 3])
  31                             as &[i32; 3]) as *const _ as *const [i32; 3]) as
  32                           *const [i32; (3 as usize)] as *const [i32; 3]);
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42                   (($crate::fmt::format as
  43                        fn(std::fmt::Arguments<'_>) -> std::string::String {std::fmt::format})(((<::std::fmt::Arguments>::new_v1
  44                                                                                                    as
  45                                                                                                    fn(&[&str], &[std::fmt::ArgumentV1<'_>]) -> std::fmt::Arguments<'_> {std::fmt::Arguments<'_>::new_v1})(({
  46                                                                                                                                                                                                                static __STATIC_FMTSTR:
  47                                                                                                                                                                                                                       &'static [&'static str]
  48                                                                                                                                                                                                                       =
  49                                                                                                                                                                                                                    (&([("test"
  50                                                                                                                                                                                                                            as
  51                                                                                                                                                                                                                            &'static str)]
  52                                                                                                                                                                                                                          as
  53                                                                                                                                                                                                                          [&'static str; 1])
  54                                                                                                                                                                                                                        as
  55                                                                                                                                                                                                                        &'static [&'static str; 1]);
  56                                                                                                                                                                                                                (__STATIC_FMTSTR
  57                                                                                                                                                                                                                    as
  58                                                                                                                                                                                                                    &'static [&'static str])
  59                                                                                                                                                                                                            }
  60                                                                                                                                                                                                               as
  61                                                                                                                                                                                                               &[&str]),
  62                                                                                                                                                                                                           (&(match (()
  63                                                                                                                                                                                                                        as
  64                                                                                                                                                                                                                        ())
  65                                                                                                                                                                                                                  {
  66                                                                                                                                                                                                                  ()
  67                                                                                                                                                                                                                  =>
  68                                                                                                                                                                                                                  ([]
  69                                                                                                                                                                                                                      as
  70                                                                                                                                                                                                                      [std::fmt::ArgumentV1<'_>; 0]),
  71                                                                                                                                                                                                              }
  72                                                                                                                                                                                                                 as
  73                                                                                                                                                                                                                 [std::fmt::ArgumentV1<'_>; 0])
  74                                                                                                                                                                                                               as
  75                                                                                                                                                                                                               &[std::fmt::ArgumentV1<'_>; 0]))
  76                                                                                                   as
  77                                                                                                   std::fmt::Arguments<'_>))
  78                       as std::string::String);
  79               } as ())
  80 pub type Foo = [i32; (3 as usize)];
  81 pub struct Bar {
  82     pub x: [i32; (3 as usize)],
  83 }
  84 pub struct TupleBar([i32; (4 as usize)]);
  85 pub enum Baz { BazVariant([i32; (5 as usize)]), }
  86 pub fn id<T>(x: T) -> T ({ (x as T) } as T)
  87 pub fn use_id() ({
  88                      let _ =
  89                          ((id::<[i32; (3 as usize)]> as
  90                               fn([i32; 3]) -> [i32; 3] {id::<[i32; 3]>})(([(1
  91                                                                                as
  92                                                                                i32),
  93                                                                            (2
  94                                                                                as
  95                                                                                i32),
  96                                                                            (3
  97                                                                                as
  98                                                                                i32)]
  99                                                                              as
 100                                                                              [i32; 3]))
 101                              as [i32; 3]);
 102                  } as ())
 103 fn main() ({ } as ())