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