src/test/ui/borrowck/borrowck-field-sensitivity-rpass.rs

   1 // run-pass
   2 #![allow(unused_mut)]
   3 #![allow(unused_variables)]
   4 // pretty-expanded FIXME #23616
   5
   6 #![feature(box_syntax)]
   7
   8 struct A { a: isize, b: Box<isize> }
   9 struct B { a: Box<isize>, b: Box<isize> }
  10
  11 fn move_after_copy() {
  12     let x = A { a: 1, b: box 2 };
  13     drop(x.a);
  14     drop(x.b);
  15 }
  16
  17 fn move_after_fu_copy() {
  18     let x = A { a: 1, b: box 2 };
  19     let _y = A { b: box 3, .. x };
  20     drop(x.b);
  21 }
  22
  23 fn fu_move_after_copy() {
  24     let x = A { a: 1, b: box 2 };
  25     drop(x.a);
  26     let _y = A { a: 3, .. x };
  27 }
  28
  29 fn fu_move_after_fu_copy() {
  30     let x = A { a: 1, b: box 2 };
  31     let _y = A { b: box 3, .. x };
  32     let _z = A { a: 4, .. x };
  33 }
  34
  35 fn copy_after_move() {
  36     let x = A { a: 1, b: box 2 };
  37     drop(x.b);
  38     drop(x.a);
  39 }
  40
  41 fn copy_after_fu_move() {
  42     let x = A { a: 1, b: box 2 };
  43     let y = A { a: 3, .. x };
  44     drop(x.a);
  45 }
  46
  47 fn fu_copy_after_move() {
  48     let x = A { a: 1, b: box 2 };
  49     drop(x.b);
  50     let _y = A { b: box 3, .. x };
  51 }
  52
  53 fn fu_copy_after_fu_move() {
  54     let x = A { a: 1, b: box 2 };
  55     let _y = A { a: 3, .. x };
  56     let _z = A { b: box 3, .. x };
  57 }
  58
  59 fn borrow_after_move() {
  60     let x = A { a: 1, b: box 2 };
  61     drop(x.b);
  62     let p = &x.a;
  63     drop(*p);
  64 }
  65
  66 fn borrow_after_fu_move() {
  67     let x = A { a: 1, b: box 2 };
  68     let _y = A { a: 3, .. x };
  69     let p = &x.a;
  70     drop(*p);
  71 }
  72
  73 fn move_after_borrow() {
  74     let x = A { a: 1, b: box 2 };
  75     let p = &x.a;
  76     drop(x.b);
  77     drop(*p);
  78 }
  79
  80 fn fu_move_after_borrow() {
  81     let x = A { a: 1, b: box 2 };
  82     let p = &x.a;
  83     let _y = A { a: 3, .. x };
  84     drop(*p);
  85 }
  86
  87 fn mut_borrow_after_mut_borrow() {
  88     let mut x = A { a: 1, b: box 2 };
  89     let p = &mut x.a;
  90     let q = &mut x.b;
  91     drop(*p);
  92     drop(**q);
  93 }
  94
  95 fn move_after_move() {
  96     let x = B { a: box 1, b: box 2 };
  97     drop(x.a);
  98     drop(x.b);
  99 }
 100
 101 fn move_after_fu_move() {
 102     let x = B { a: box 1, b: box 2 };
 103     let y = B { a: box 3, .. x };
 104     drop(x.a);
 105 }
 106
 107 fn fu_move_after_move() {
 108     let x = B { a: box 1, b: box 2 };
 109     drop(x.a);
 110     let z = B { a: box 3, .. x };
 111     drop(z.b);
 112 }
 113
 114 fn fu_move_after_fu_move() {
 115     let x = B { a: box 1, b: box 2 };
 116     let _y = B { b: box 3, .. x };
 117     let _z = B { a: box 4, .. x };
 118 }
 119
 120 fn copy_after_assign_after_move() {
 121     let mut x = A { a: 1, b: box 2 };
 122     drop(x.b);
 123     x = A { a: 3, b: box 4 };
 124     drop(*x.b);
 125 }
 126
 127 fn copy_after_assign_after_fu_move() {
 128     let mut x = A { a: 1, b: box 2 };
 129     let _y = A { a: 3, .. x };
 130     x = A { a: 3, b: box 4 };
 131     drop(*x.b);
 132 }
 133
 134 fn copy_after_field_assign_after_move() {
 135     let mut x = A { a: 1, b: box 2 };
 136     drop(x.b);
 137     x.b = box 3;
 138     drop(*x.b);
 139 }
 140
 141 fn copy_after_field_assign_after_fu_move() {
 142     let mut x = A { a: 1, b: box 2 };
 143     let _y = A { a: 3, .. x };
 144     x.b = box 3;
 145     drop(*x.b);
 146 }
 147
 148 fn borrow_after_assign_after_move() {
 149     let mut x = A { a: 1, b: box 2 };
 150     drop(x.b);
 151     x = A { a: 3, b: box 4 };
 152     let p = &x.b;
 153     drop(**p);
 154 }
 155
 156 fn borrow_after_assign_after_fu_move() {
 157     let mut x = A { a: 1, b: box 2 };
 158     let _y = A { a: 3, .. x };
 159     x = A { a: 3, b: box 4 };
 160     let p = &x.b;
 161     drop(**p);
 162 }
 163
 164 fn borrow_after_field_assign_after_move() {
 165     let mut x = A { a: 1, b: box 2 };
 166     drop(x.b);
 167     x.b = box 3;
 168     let p = &x.b;
 169     drop(**p);
 170 }
 171
 172 fn borrow_after_field_assign_after_fu_move() {
 173     let mut x = A { a: 1, b: box 2 };
 174     let _y = A { a: 3, .. x };
 175     x.b = box 3;
 176     let p = &x.b;
 177     drop(**p);
 178 }
 179
 180 fn move_after_assign_after_move() {
 181     let mut x = A { a: 1, b: box 2 };
 182     let _y = x.b;
 183     x = A { a: 3, b: box 4 };
 184     drop(x.b);
 185 }
 186
 187 fn move_after_assign_after_fu_move() {
 188     let mut x = A { a: 1, b: box 2 };
 189     let _y = A { a: 3, .. x };
 190     x = A { a: 3, b: box 4 };
 191     drop(x.b);
 192 }
 193
 194 fn move_after_field_assign_after_move() {
 195     let mut x = A { a: 1, b: box 2 };
 196     drop(x.b);
 197     x.b = box 3;
 198     drop(x.b);
 199 }
 200
 201 fn move_after_field_assign_after_fu_move() {
 202     let mut x = A { a: 1, b: box 2 };
 203     let _y = A { a: 3, .. x };
 204     x.b = box 3;
 205     drop(x.b);
 206 }
 207
 208 fn copy_after_assign_after_uninit() {
 209     let mut x: A;
 210     x = A { a: 1, b: box 2 };
 211     drop(x.a);
 212 }
 213
 214 fn borrow_after_assign_after_uninit() {
 215     let mut x: A;
 216     x = A { a: 1, b: box 2 };
 217     let p = &x.a;
 218     drop(*p);
 219 }
 220
 221 fn move_after_assign_after_uninit() {
 222     let mut x: A;
 223     x = A { a: 1, b: box 2 };
 224     drop(x.b);
 225 }
 226
 227 fn main() {
 228     move_after_copy();
 229     move_after_fu_copy();
 230     fu_move_after_copy();
 231     fu_move_after_fu_copy();
 232     copy_after_move();
 233     copy_after_fu_move();
 234     fu_copy_after_move();
 235     fu_copy_after_fu_move();
 236
 237     borrow_after_move();
 238     borrow_after_fu_move();
 239     move_after_borrow();
 240     fu_move_after_borrow();
 241     mut_borrow_after_mut_borrow();
 242
 243     move_after_move();
 244     move_after_fu_move();
 245     fu_move_after_move();
 246     fu_move_after_fu_move();
 247
 248     copy_after_assign_after_move();
 249     copy_after_assign_after_fu_move();
 250     copy_after_field_assign_after_move();
 251     copy_after_field_assign_after_fu_move();
 252
 253     borrow_after_assign_after_move();
 254     borrow_after_assign_after_fu_move();
 255     borrow_after_field_assign_after_move();
 256     borrow_after_field_assign_after_fu_move();
 257
 258     move_after_assign_after_move();
 259     move_after_assign_after_fu_move();
 260     move_after_field_assign_after_move();
 261     move_after_field_assign_after_fu_move();
 262
 263     copy_after_assign_after_uninit();
 264     borrow_after_assign_after_uninit();
 265     move_after_assign_after_uninit();
 266 }