fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #67350 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum73528e339aa

1.40.0
7.3 KiB83 linesraw
1#[prelude_import]
2use ::std::prelude::v1::*;
3#[macro_use]
4extern 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
11pub fn foo(_: [i32; (3 as usize)]) ({ } as ())
12
13pub 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                  ((::alloc::fmt::format as
33                       for<'r> fn(std::fmt::Arguments<'r>) -> std::string::String {std::fmt::format})(((::core::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 ())
60pub type Foo = [i32; (3 as usize)];
61pub struct Bar {
62    pub x: [i32; (3 as usize)],
63}
64pub struct TupleBar([i32; (4 as usize)]);
65pub enum Baz { BazVariant([i32; (5 as usize)]), }
66pub fn id<T>(x: T) -> T ({ (x as T) } as T)
67pub 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 ())
83fn main() ({ } as ())