1 // Copyright (C) 2016-2021 Free Software Foundation, Inc.
2
3 // This program is free software; you can redistribute it and/or modify
4 // it under the terms of the GNU General Public License as published by
5 // the Free Software Foundation; either version 3 of the License, or
6 // (at your option) any later version.
7 //
8 // This program is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 // GNU General Public License for more details.
12 //
13 // You should have received a copy of the GNU General Public License
14 // along with this program. If not, see <http://www.gnu.org/licenses/>.
15
16 #![allow(dead_code)]
17 #![allow(unused_variables)]
18 #![allow(unused_assignments)]
19
20
21 pub struct HiBob {
22 pub field1: i32,
23 field2: u64,
24 }
25
26 struct ByeBob(i32, u64);
27
28 enum Something {
29 One,
30 Two,
31 Three
32 }
33
34 enum MoreComplicated {
35 One,
36 Two(i32),
37 Three(HiBob),
38 Four{this: bool, is: u8, a: char, struct_: u64, variant: u32},
39 }
40
41 // tests the nonzero optimization, but fields are reversed
42 enum NonZeroOptimized {
43 Empty,
44 Value(String),
45 }
46
diff2(x: i32, y: i32) -> i3247 fn diff2(x: i32, y: i32) -> i32 {
48 x - y
49 }
50
51 // Empty function, should not have "void"
52 // or "()" in its return type
empty()53 fn empty() {
54
55 }
56
57 pub struct Unit;
58
59 // This triggers the non-zero optimization that yields a different
60 // enum representation in the debug info.
61 enum SpaceSaver {
62 Thebox(u8, Box<i32>),
63 Nothing,
64 }
65
66 enum Univariant {
67 Foo {a: u8}
68 }
69 enum UnivariantAnon {
70 Foo(u8)
71 }
72
73 enum ParametrizedEnum<T> {
74 Val { val: T },
75 Empty,
76 }
77
78 struct ParametrizedStruct<T> {
79 next: ParametrizedEnum<Box<ParametrizedStruct<T>>>,
80 value: T
81 }
82
83 struct StringAtOffset {
84 pub field1: &'static str,
85 pub field2: i32,
86 pub field3: &'static str,
87 }
88
89 // A simple structure whose layout won't be changed by the compiler,
90 // so that ptype/o testing will work on any platform.
91 struct SimpleLayout {
92 f1: u16,
93 f2: u16
94 }
95
96 enum EmptyEnum {}
97
98 #[derive(Debug)]
99 struct EnumWithNonzeroOffset {
100 a: Option<u8>,
101 b: Option<u8>,
102 }
103
main()104 fn main () {
105 let a = ();
106 let b : [i32; 0] = [];
107
108 let mut c = 27;
109 let d = c = 99;
110
111 let e = MoreComplicated::Two(73);
112 let e2 = MoreComplicated::Four {this: true, is: 8, a: 'm',
113 struct_: 100, variant: 10};
114
115 let f = "hi bob";
116 let g = b"hi bob";
117 let h = b'9';
118
119 let fslice = &f[3..];
120
121 let i = ["whatever"; 8];
122
123 let j = Unit;
124 let j2 = Unit{};
125
126 let k = SpaceSaver::Nothing;
127 let l = SpaceSaver::Thebox(9, Box::new(1729));
128
129 let v = Something::Three;
130 let w = [1,2,3,4];
131 let w_ptr = &w[0];
132 let x = (23, 25.5);
133 let y = HiBob {field1: 7, field2: 8};
134 let z = ByeBob(7, 8);
135
136 let field1 = 77;
137 let field2 = 88;
138
139 let univariant = Univariant::Foo {a : 1};
140 let univariant_anon = UnivariantAnon::Foo(1);
141
142 let slice = &w[2..3];
143 let fromslice = slice[0];
144 let slice2 = &slice[0..1];
145
146 let all1 = &w[..];
147 let all2 = &slice[..];
148
149 let from1 = &w[1..];
150 let from2 = &slice[1..];
151
152 let to1 = &w[..3];
153 let to2 = &slice[..1];
154
155 let st = StringAtOffset { field1: "hello", field2: 1, field3: "world" };
156
157 // tests for enum optimizations
158
159 let str_some = Some("hi".to_string());
160 let str_none = None::<String>;
161 let box_some = Some(Box::new(1u8));
162 let box_none = None::<Box<u8>>;
163 let int_some = Some(1u8);
164 let int_none = None::<u8>;
165 let custom_some = NonZeroOptimized::Value("hi".into());
166 let custom_none = NonZeroOptimized::Empty;
167
168 let parametrized = ParametrizedStruct {
169 next: ParametrizedEnum::Val {
170 val: Box::new(ParametrizedStruct {
171 next: ParametrizedEnum::Empty,
172 value: 1,
173 })
174 },
175 value: 0,
176 };
177
178 let simplelayout = SimpleLayout { f1: 8, f2: 9 };
179
180 let empty_enum_value: EmptyEnum;
181
182 let nonzero_offset = EnumWithNonzeroOffset { a: Some(1), b: None };
183
184 println!("{}, {}", x.0, x.1); // set breakpoint here
185 println!("{}", diff2(92, 45));
186 empty();
187 }
188