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 trait Whatever { 22 fn whatever(&self) -> i32; 23 fn static_i32(x: i32) -> Self; 24} 25 26impl Whatever for i32 { 27 fn whatever(&self) -> i32 { 28 *self // set breakpoint 2 here 29 } 30 31 fn static_i32(x: i32) -> i32 { 32 x 33 } 34} 35 36pub struct HasMethods { 37 value: i32 38} 39 40impl HasMethods { 41 pub fn new() -> HasMethods { 42 HasMethods { value: 0 } 43 } 44 45 pub fn incr(&mut self) -> &mut HasMethods { 46 self.value += 1; 47 self 48 } 49 50 pub fn take(self) -> HasMethods { 51 self 52 } 53} 54 55impl Whatever for HasMethods { 56 fn whatever(&self) -> i32 { 57 self.value 58 } 59 60 fn static_i32(x: i32) -> HasMethods { 61 HasMethods{value: x} 62 } 63} 64 65enum SomeEnum { 66 One, 67 Two, 68 Three(i32), 69 Four{x: i32} 70} 71 72impl SomeEnum { 73 fn value(&self) -> i32 { 74 match *self { 75 SomeEnum::Three(x) => x, 76 SomeEnum::Four{x} => x, 77 _ => 0 78 } 79 } 80 81 fn mut_value(&mut self) -> i32 { 82 match *self { 83 SomeEnum::Three(x) => x, 84 SomeEnum::Four{x} => x, 85 _ => 0 86 } 87 } 88 89 fn take_value(self) -> (i32, SomeEnum) { 90 (match self { 91 SomeEnum::Three(x) => x, 92 SomeEnum::Four{x} => x, 93 _ => 0 94 }, self) 95 } 96} 97 98enum SimpleEnum { 99 One, 100 Two, 101 Three 102} 103 104impl SimpleEnum { 105 fn value(&self) -> i32 { 106 match *self { 107 SimpleEnum::One => 1, 108 SimpleEnum::Two => 2, 109 SimpleEnum::Three => 452, 110 } 111 } 112} 113 114fn main() { 115 let mut a = SomeEnum::Three(23); 116 let av = a.value(); 117 let amv = (&mut a).mut_value(); 118 let atv = a.take_value(); 119 let b = SomeEnum::Four{x: 24}; 120 let bv = b.value(); 121 let c = SimpleEnum::Three; 122 let d = c.value(); 123 let mut x = HasMethods::new(); 124 x.incr(); // set breakpoint 1 here 125 (&mut x).incr(); 126 let y = 23i32.whatever(); 127 println!("{}", y); 128 let z = x.take(); 129} 130