1 // Copyright (C) 2016-2019 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 47 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 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 union Union { 84 f1: i8, 85 f2: u8, 86 } 87 88 // A simple structure whose layout won't be changed by the compiler, 89 // so that ptype/o testing will work on any platform. 90 struct SimpleLayout { 91 f1: u16, 92 f2: u16 93 } 94 95 enum EmptyEnum {} 96 97 fn main () { 98 let a = (); 99 let b : [i32; 0] = []; 100 101 let mut c = 27; 102 let d = c = 99; 103 104 let e = MoreComplicated::Two(73); 105 let e2 = MoreComplicated::Four {this: true, is: 8, a: 'm', 106 struct_: 100, variant: 10}; 107 108 let f = "hi bob"; 109 let g = b"hi bob"; 110 let h = b'9'; 111 112 let fslice = &f[3..]; 113 114 let i = ["whatever"; 8]; 115 116 let j = Unit; 117 let j2 = Unit{}; 118 119 let k = SpaceSaver::Nothing; 120 let l = SpaceSaver::Thebox(9, Box::new(1729)); 121 122 let v = Something::Three; 123 let w = [1,2,3,4]; 124 let w_ptr = &w[0]; 125 let x = (23, 25.5); 126 let y = HiBob {field1: 7, field2: 8}; 127 let z = ByeBob(7, 8); 128 129 let field1 = 77; 130 let field2 = 88; 131 let y0 = HiBob { field1, field2 }; 132 133 let univariant = Univariant::Foo {a : 1}; 134 let univariant_anon = UnivariantAnon::Foo(1); 135 136 let slice = &w[2..3]; 137 let fromslice = slice[0]; 138 let slice2 = &slice[0..1]; 139 140 let all1 = &w[..]; 141 let all2 = &slice[..]; 142 143 let from1 = &w[1..]; 144 let from2 = &slice[1..]; 145 146 let to1 = &w[..3]; 147 let to2 = &slice[..1]; 148 149 // tests for enum optimizations 150 151 let str_some = Some("hi".to_string()); 152 let str_none = None::<String>; 153 let box_some = Some(Box::new(1u8)); 154 let box_none = None::<Box<u8>>; 155 let int_some = Some(1u8); 156 let int_none = None::<u8>; 157 let custom_some = NonZeroOptimized::Value("hi".into()); 158 let custom_none = NonZeroOptimized::Empty; 159 160 let parametrized = ParametrizedStruct { 161 next: ParametrizedEnum::Val { 162 val: Box::new(ParametrizedStruct { 163 next: ParametrizedEnum::Empty, 164 value: 1, 165 }) 166 }, 167 value: 0, 168 }; 169 170 let u = Union { f2: 255 }; 171 let simplelayout = SimpleLayout { f1: 8, f2: 9 }; 172 173 let empty_enum_value: EmptyEnum; 174 175 println!("{}, {}", x.0, x.1); // set breakpoint here 176 println!("{}", diff2(92, 45)); 177 empty(); 178 } 179