fork/rust

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

borsAuto merge of #71868 - Mark-Simulacrum:stable-1.43.1, r=pietroalbini8d69840ab92

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