1 #[macro_use] 2 mod compiletest; 3 4 assert_no_panic! { 5 mod test_readme { 6 #[no_panic] 7 fn demo(s: &str) -> &str { 8 &s[1..] 9 } 10 11 fn main() { 12 println!("{}", demo("input string")); 13 } 14 } 15 16 mod test_method_in_impl { 17 struct S; 18 19 impl S { 20 #[no_panic] 21 fn demo(self) -> &'static str { 22 "test" 23 } 24 } 25 26 fn main() { 27 println!("{}", S.demo()); 28 } 29 } 30 31 mod test_lifetime_elision { 32 struct Buffer { 33 bytes: [u8; 24], 34 } 35 36 #[no_panic] 37 fn demo(buffer: &mut Buffer) -> &[u8] { 38 &buffer.bytes[..] 39 } 40 41 fn main() { 42 let mut buffer = Buffer { 43 bytes: [0u8; 24], 44 }; 45 println!("{:?}", demo(&mut buffer)); 46 } 47 } 48 49 mod test_receiver_lifetime_elision { 50 struct Buffer { 51 bytes: [u8; 24], 52 } 53 54 impl Buffer { 55 #[no_panic] 56 fn demo(&mut self, _s: &str) -> &[u8] { 57 &self.bytes[..] 58 } 59 } 60 61 fn main() { 62 let mut buffer = Buffer { 63 bytes: [0u8; 24], 64 }; 65 println!("{:?}", buffer.demo("")); 66 } 67 } 68 69 mod test_ref_argument { 70 #[no_panic] 71 fn demo(ref i: i32) -> i32 { 72 *i 73 } 74 75 fn main() { 76 println!("{}", demo(0)); 77 } 78 } 79 80 mod test_mut_argument { 81 #[no_panic] 82 fn demo(mut i: i32) -> i32 { 83 i += 1; 84 i 85 } 86 87 fn main() { 88 println!("{}", demo(0)); 89 } 90 } 91 92 mod test_ref_mut_argument { 93 #[no_panic] 94 fn demo(ref mut i: i32) -> i32 { 95 *i += 1; 96 *i 97 } 98 99 fn main() { 100 println!("{}", demo(0)); 101 } 102 } 103 104 mod test_borrow_from_mut_self { 105 struct S { 106 data: usize, 107 } 108 109 impl S { 110 #[no_panic] 111 fn get_mut(&mut self) -> &mut usize { 112 &mut self.data 113 } 114 } 115 116 fn main() { 117 let mut s = S { data: 0 }; 118 println!("{}", s.get_mut()); 119 } 120 } 121 122 mod test_self_in_vec { 123 struct S { 124 data: usize, 125 } 126 127 impl S { 128 #[no_panic] 129 fn get_mut(&mut self) -> Vec<usize> { 130 vec![self.data] 131 } 132 } 133 134 fn main() { 135 let mut s = S { data: 0 }; 136 println!("{}", s.get_mut()[0]); 137 } 138 } 139 140 mod test_self_in_macro_containing_fn { 141 pub struct S { 142 data: usize, 143 } 144 145 macro_rules! emit { 146 ($($tt:tt)*) => { 147 $($tt)* 148 }; 149 } 150 151 impl S { 152 #[no_panic] 153 fn get_mut(&mut self) -> usize { 154 let _ = emit!({ 155 impl S { 156 pub fn f(self) {} 157 } 158 }); 159 self.data 160 } 161 } 162 163 fn main() { 164 let mut s = S { data: 0 }; 165 println!("{}", s.get_mut()); 166 } 167 } 168 } 169 170 assert_link_error! { 171 mod test_readme { 172 #[no_panic] 173 fn demo(s: &str) -> &str { 174 &s[1..] 175 } 176 177 fn main() { 178 println!("{}", demo("\u{1f980}input string")); 179 } 180 } 181 } 182