1// Copyright (C) 2016-2023 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
21pub struct HiBob {
22    pub field1: i32,
23    field2: u64,
24}
25
26struct ByeBob(i32, u64);
27
28enum Something {
29    One,
30    Two,
31    Three
32}
33
34enum 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
42enum NonZeroOptimized {
43    Empty,
44    Value(String),
45}
46
47fn diff2(x: i32, y: i32) -> i32 {
48    x - y
49}
50
51// Empty function, should not have "void"
52// or "()" in its return type
53fn empty() {
54
55}
56
57pub struct Unit;
58
59// This triggers the non-zero optimization that yields a different
60// enum representation in the debug info.
61enum SpaceSaver {
62    Thebox(u8, Box<i32>),
63    Nothing,
64}
65
66enum Univariant {
67    Foo {a: u8}
68}
69enum UnivariantAnon {
70    Foo(u8)
71}
72
73enum ParametrizedEnum<T> {
74    Val { val: T },
75    Empty,
76}
77
78struct ParametrizedStruct<T> {
79    next: ParametrizedEnum<Box<ParametrizedStruct<T>>>,
80    value: T
81}
82
83struct 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.
91struct SimpleLayout {
92    f1: u16,
93    f2: u16
94}
95
96enum EmptyEnum {}
97
98#[derive(Debug)]
99struct EnumWithNonzeroOffset {
100    a: Option<u8>,
101    b: Option<u8>,
102}
103
104fn 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