From 53198ffda6cb39721afab0fc35941b4379ecae1f Mon Sep 17 00:00:00 2001 From: Cameron Zwarich Date: Sat, 7 Jun 2014 00:29:24 -0700 Subject: [PATCH 1/5] Mention the specific kind of use in borrowck test function names Some of the borrowck field-sensitivity test functions have 'use' in their name, but they don't refer to the specific kind of use (whether a copy or a deref). It would be better if the name more precisely reflected what the function is testing. --- .../borrowck-field-sensitivity.rs | 12 ++--- .../run-pass/borrowck-field-sensitivity.rs | 44 +++++++++---------- 2 files changed, 28 insertions(+), 28 deletions(-) diff --git a/src/test/compile-fail/borrowck-field-sensitivity.rs b/src/test/compile-fail/borrowck-field-sensitivity.rs index 4363f85048f0e..3d303625182bf 100644 --- a/src/test/compile-fail/borrowck-field-sensitivity.rs +++ b/src/test/compile-fail/borrowck-field-sensitivity.rs @@ -12,13 +12,13 @@ struct A { a: int, b: Box } fn borrow(_: &T) { } -fn use_after_move() { +fn deref_after_move() { let x = A { a: 1, b: box 2 }; drop(x.b); drop(*x.b); //~ ERROR use of partially moved value: `*x.b` } -fn use_after_fu_move() { +fn deref_after_fu_move() { let x = A { a: 1, b: box 2 }; let y = A { a: 3, .. x }; drop(*x.b); //~ ERROR use of partially moved value: `*x.b` @@ -84,7 +84,7 @@ fn fu_move_after_fu_move() { // The following functions aren't yet accepted, but they should be. -fn use_after_field_assign_after_uninit() { +fn copy_after_field_assign_after_uninit() { let mut x: A; x.a = 1; drop(x.a); //~ ERROR use of possibly uninitialized variable: `x.a` @@ -103,8 +103,8 @@ fn move_after_field_assign_after_uninit() { } fn main() { - use_after_move(); - use_after_fu_move(); + deref_after_move(); + deref_after_fu_move(); borrow_after_move(); borrow_after_fu_move(); @@ -117,7 +117,7 @@ fn main() { fu_move_after_move(); fu_move_after_fu_move(); - use_after_field_assign_after_uninit(); + copy_after_field_assign_after_uninit(); borrow_after_field_assign_after_uninit(); move_after_field_assign_after_uninit(); } diff --git a/src/test/run-pass/borrowck-field-sensitivity.rs b/src/test/run-pass/borrowck-field-sensitivity.rs index 3b82f51123f8d..9baa9ca7c6b5e 100644 --- a/src/test/run-pass/borrowck-field-sensitivity.rs +++ b/src/test/run-pass/borrowck-field-sensitivity.rs @@ -13,52 +13,52 @@ struct B { a: Box, b: Box } fn borrow(_: &T) { } -fn move_after_use() { +fn move_after_copy() { let x = A { a: 1, b: box 2 }; drop(x.a); drop(x.b); } -fn move_after_fu_use() { +fn move_after_fu_copy() { let x = A { a: 1, b: box 2 }; let _y = A { b: box 3, .. x }; drop(x.b); } -fn fu_move_after_use() { +fn fu_move_after_copy() { let x = A { a: 1, b: box 2 }; drop(x.a); let y = A { a: 3, .. x }; drop(y.b); } -fn fu_move_after_fu_use() { +fn fu_move_after_fu_copy() { let x = A { a: 1, b: box 2 }; let _y = A { b: box 3, .. x }; let z = A { a: 4, .. x }; drop(z.b); } -fn use_after_move() { +fn copy_after_move() { let x = A { a: 1, b: box 2 }; drop(x.b); drop(x.a); } -fn use_after_fu_move() { +fn copy_after_fu_move() { let x = A { a: 1, b: box 2 }; let y = A { a: 3, .. x }; drop(x.a); drop(y.b); } -fn fu_use_after_move() { +fn fu_copy_after_move() { let x = A { a: 1, b: box 2 }; drop(x.b); let _y = A { b: box 3, .. x }; } -fn fu_use_after_fu_move() { +fn fu_copy_after_fu_move() { let x = A { a: 1, b: box 2 }; let y = A { a: 3, .. x }; let _z = A { b: box 3, .. x }; @@ -127,14 +127,14 @@ fn fu_move_after_fu_move() { drop(z.b); } -fn use_after_assign_after_move() { +fn copy_after_assign_after_move() { let mut x = A { a: 1, b: box 2 }; drop(x.b); x = A { a: 3, b: box 4 }; drop(*x.b); } -fn use_after_field_assign_after_move() { +fn copy_after_field_assign_after_move() { let mut x = A { a: 1, b: box 2 }; drop(x.b); x.b = box 3; @@ -170,7 +170,7 @@ fn move_after_field_assign_after_move() { drop(x.b); } -fn use_after_assign_after_uninit() { +fn copy_after_assign_after_uninit() { let mut x: A; x = A { a: 1, b: box 2 }; drop(x.a); @@ -189,14 +189,14 @@ fn move_after_assign_after_uninit() { } fn main() { - move_after_use(); - move_after_fu_use(); - fu_move_after_use(); - fu_move_after_fu_use(); - use_after_move(); - use_after_fu_move(); - fu_use_after_move(); - fu_use_after_fu_move(); + move_after_copy(); + move_after_fu_copy(); + fu_move_after_copy(); + fu_move_after_fu_copy(); + copy_after_move(); + copy_after_fu_move(); + fu_copy_after_move(); + fu_copy_after_fu_move(); borrow_after_move(); borrow_after_fu_move(); @@ -209,14 +209,14 @@ fn main() { fu_move_after_move(); fu_move_after_fu_move(); - use_after_assign_after_move(); - use_after_field_assign_after_move(); + copy_after_assign_after_move(); + copy_after_field_assign_after_move(); borrow_after_assign_after_move(); borrow_after_field_assign_after_move(); move_after_assign_after_move(); move_after_field_assign_after_move(); - use_after_assign_after_uninit(); + copy_after_assign_after_uninit(); borrow_after_assign_after_uninit(); move_after_assign_after_uninit(); } From 8a543ffc76eea08db59cffbd6f8be7926bdb78c2 Mon Sep 17 00:00:00 2001 From: Cameron Zwarich Date: Sat, 7 Jun 2014 02:20:44 -0700 Subject: [PATCH 2/5] Make borrowck test functions better match their names A number of borrowck field-sensitivity tests perform more moves and copies than their naming scheme would indicate. This is only necessary for borrowed pointers (to ensure that the borrowws stay alive in the near future when borrow liveness is tracked), but all other test functions should be changed to match their name more closely. --- .../run-pass/borrowck-field-sensitivity.rs | 26 ++++++------------- 1 file changed, 8 insertions(+), 18 deletions(-) diff --git a/src/test/run-pass/borrowck-field-sensitivity.rs b/src/test/run-pass/borrowck-field-sensitivity.rs index 9baa9ca7c6b5e..202df70f5d2fd 100644 --- a/src/test/run-pass/borrowck-field-sensitivity.rs +++ b/src/test/run-pass/borrowck-field-sensitivity.rs @@ -28,15 +28,13 @@ fn move_after_fu_copy() { fn fu_move_after_copy() { let x = A { a: 1, b: box 2 }; drop(x.a); - let y = A { a: 3, .. x }; - drop(y.b); + let _y = A { a: 3, .. x }; } fn fu_move_after_fu_copy() { let x = A { a: 1, b: box 2 }; let _y = A { b: box 3, .. x }; - let z = A { a: 4, .. x }; - drop(z.b); + let _z = A { a: 4, .. x }; } fn copy_after_move() { @@ -49,7 +47,6 @@ fn copy_after_fu_move() { let x = A { a: 1, b: box 2 }; let y = A { a: 3, .. x }; drop(x.a); - drop(y.b); } fn fu_copy_after_move() { @@ -60,9 +57,8 @@ fn fu_copy_after_move() { fn fu_copy_after_fu_move() { let x = A { a: 1, b: box 2 }; - let y = A { a: 3, .. x }; + let _y = A { a: 3, .. x }; let _z = A { b: box 3, .. x }; - drop(y.b); } fn borrow_after_move() { @@ -73,9 +69,8 @@ fn borrow_after_move() { fn borrow_after_fu_move() { let x = A { a: 1, b: box 2 }; - let y = A { a: 3, .. x }; + let _y = A { a: 3, .. x }; borrow(&x.a); - drop(y.b); } fn move_after_borrow() { @@ -87,8 +82,7 @@ fn move_after_borrow() { fn fu_move_after_borrow() { let x = A { a: 1, b: box 2 }; borrow(&x.a); - let y = A { a: 3, .. x }; - drop(y.b); + let _y = A { a: 3, .. x }; } fn mut_borrow_after_mut_borrow() { @@ -109,7 +103,6 @@ fn move_after_fu_move() { let x = B { a: box 1, b: box 2 }; let y = B { a: box 3, .. x }; drop(x.a); - drop(y.b); } fn fu_move_after_move() { @@ -121,10 +114,8 @@ fn fu_move_after_move() { fn fu_move_after_fu_move() { let x = B { a: box 1, b: box 2 }; - let y = B { b: box 3, .. x }; - let z = B { a: box 4, .. x }; - drop(y.a); - drop(z.b); + let _y = B { b: box 3, .. x }; + let _z = B { a: box 4, .. x }; } fn copy_after_assign_after_move() { @@ -157,10 +148,9 @@ fn borrow_after_field_assign_after_move() { fn move_after_assign_after_move() { let mut x = A { a: 1, b: box 2 }; - let y = x.b; + let _y = x.b; x = A { a: 3, b: box 4 }; drop(x.b); - drop(y); } fn move_after_field_assign_after_move() { From 61c81bf00cc8f8a87940fce3ba7be0bfd66cf04f Mon Sep 17 00:00:00 2001 From: Cameron Zwarich Date: Sat, 7 Jun 2014 00:44:01 -0700 Subject: [PATCH 3/5] Add more borrowck tests for functional update moves Add more borrowck field-sensitivity tests for functional update moves. This makes the collection of test functions more combinatorially exhaustive. --- .../run-pass/borrowck-field-sensitivity.rs | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/src/test/run-pass/borrowck-field-sensitivity.rs b/src/test/run-pass/borrowck-field-sensitivity.rs index 202df70f5d2fd..7f9a1427d7252 100644 --- a/src/test/run-pass/borrowck-field-sensitivity.rs +++ b/src/test/run-pass/borrowck-field-sensitivity.rs @@ -125,6 +125,13 @@ fn copy_after_assign_after_move() { drop(*x.b); } +fn copy_after_assign_after_fu_move() { + let mut x = A { a: 1, b: box 2 }; + let _y = A { a: 3, .. x }; + x = A { a: 3, b: box 4 }; + drop(*x.b); +} + fn copy_after_field_assign_after_move() { let mut x = A { a: 1, b: box 2 }; drop(x.b); @@ -132,6 +139,13 @@ fn copy_after_field_assign_after_move() { drop(*x.b); } +fn copy_after_field_assign_after_fu_move() { + let mut x = A { a: 1, b: box 2 }; + let _y = A { a: 3, .. x }; + x.b = box 3; + drop(*x.b); +} + fn borrow_after_assign_after_move() { let mut x = A { a: 1, b: box 2 }; drop(x.b); @@ -139,6 +153,13 @@ fn borrow_after_assign_after_move() { borrow(&x.b); } +fn borrow_after_assign_after_fu_move() { + let mut x = A { a: 1, b: box 2 }; + let _y = A { a: 3, .. x }; + x = A { a: 3, b: box 4 }; + borrow(&x.b); +} + fn borrow_after_field_assign_after_move() { let mut x = A { a: 1, b: box 2 }; drop(x.b); @@ -146,6 +167,13 @@ fn borrow_after_field_assign_after_move() { borrow(&x.b); } +fn borrow_after_field_assign_after_fu_move() { + let mut x = A { a: 1, b: box 2 }; + let _y = A { a: 3, .. x }; + x.b = box 3; + borrow(&x.b); +} + fn move_after_assign_after_move() { let mut x = A { a: 1, b: box 2 }; let _y = x.b; @@ -153,6 +181,13 @@ fn move_after_assign_after_move() { drop(x.b); } +fn move_after_assign_after_fu_move() { + let mut x = A { a: 1, b: box 2 }; + let _y = A { a: 3, .. x }; + x = A { a: 3, b: box 4 }; + drop(x.b); +} + fn move_after_field_assign_after_move() { let mut x = A { a: 1, b: box 2 }; drop(x.b); @@ -160,6 +195,13 @@ fn move_after_field_assign_after_move() { drop(x.b); } +fn move_after_field_assign_after_fu_move() { + let mut x = A { a: 1, b: box 2 }; + let _y = A { a: 3, .. x }; + x.b = box 3; + drop(x.b); +} + fn copy_after_assign_after_uninit() { let mut x: A; x = A { a: 1, b: box 2 }; @@ -200,11 +242,19 @@ fn main() { fu_move_after_fu_move(); copy_after_assign_after_move(); + copy_after_assign_after_fu_move(); copy_after_field_assign_after_move(); + copy_after_field_assign_after_fu_move(); + borrow_after_assign_after_move(); + borrow_after_assign_after_fu_move(); borrow_after_field_assign_after_move(); + borrow_after_field_assign_after_fu_move(); + move_after_assign_after_move(); + move_after_assign_after_fu_move(); move_after_field_assign_after_move(); + move_after_field_assign_after_fu_move(); copy_after_assign_after_uninit(); borrow_after_assign_after_uninit(); From 653f57af2085534ced338bd146e2528b81c9fd11 Mon Sep 17 00:00:00 2001 From: Cameron Zwarich Date: Sat, 7 Jun 2014 02:46:35 -0700 Subject: [PATCH 4/5] Fix bad borrowck tests and move them from run-pass to compile-fail The move_after_borrow / fu_move_after_borrow tests in run-pass/borrowck-field-sensitivity.rs are not testing the right thing, since the scope of the borrow is limited to the call to borrow(). When fixed, these tests fail and thus should be moved to the corresponding compile-fail test file. --- .../compile-fail/borrowck-field-sensitivity.rs | 17 +++++++++++++++++ src/test/run-pass/borrowck-field-sensitivity.rs | 14 -------------- 2 files changed, 17 insertions(+), 14 deletions(-) diff --git a/src/test/compile-fail/borrowck-field-sensitivity.rs b/src/test/compile-fail/borrowck-field-sensitivity.rs index 3d303625182bf..9a0d81e733208 100644 --- a/src/test/compile-fail/borrowck-field-sensitivity.rs +++ b/src/test/compile-fail/borrowck-field-sensitivity.rs @@ -84,6 +84,20 @@ fn fu_move_after_fu_move() { // The following functions aren't yet accepted, but they should be. +fn move_after_borrow_correct() { + let x = A { a: 1, b: box 2 }; + let p = &x.a; + drop(x.b); //~ ERROR cannot move out of `x.b` because it is borrowed + drop(*p); +} + +fn fu_move_after_borrow_correct() { + let x = A { a: 1, b: box 2 }; + let p = &x.a; + let _y = A { a: 3, .. x }; //~ ERROR cannot move out of `x.b` because it is borrowed + drop(*p); +} + fn copy_after_field_assign_after_uninit() { let mut x: A; x.a = 1; @@ -117,6 +131,9 @@ fn main() { fu_move_after_move(); fu_move_after_fu_move(); + move_after_borrow_correct(); + fu_move_after_borrow_correct(); + copy_after_field_assign_after_uninit(); borrow_after_field_assign_after_uninit(); move_after_field_assign_after_uninit(); diff --git a/src/test/run-pass/borrowck-field-sensitivity.rs b/src/test/run-pass/borrowck-field-sensitivity.rs index 7f9a1427d7252..2500ec764ebaa 100644 --- a/src/test/run-pass/borrowck-field-sensitivity.rs +++ b/src/test/run-pass/borrowck-field-sensitivity.rs @@ -73,18 +73,6 @@ fn borrow_after_fu_move() { borrow(&x.a); } -fn move_after_borrow() { - let x = A { a: 1, b: box 2 }; - borrow(&x.a); - drop(x.b); -} - -fn fu_move_after_borrow() { - let x = A { a: 1, b: box 2 }; - borrow(&x.a); - let _y = A { a: 3, .. x }; -} - fn mut_borrow_after_mut_borrow() { let mut x = A { a: 1, b: box 2 }; let y = &mut x.a; @@ -232,8 +220,6 @@ fn main() { borrow_after_move(); borrow_after_fu_move(); - move_after_borrow(); - fu_move_after_borrow(); mut_borrow_after_mut_borrow(); move_after_move(); From 4666792ac600f4e4e1c09a37b88f40f6125b57b8 Mon Sep 17 00:00:00 2001 From: Cameron Zwarich Date: Sat, 7 Jun 2014 02:55:00 -0700 Subject: [PATCH 5/5] Clean up borrows in borrowck field-sensitivity tests Instead of calling a borrow() function that takes a pointer type, just create a local pointer and dereference it. The dereference is there to outsmart any future liveness analysis in borrowck. --- .../borrowck-field-sensitivity.rs | 29 ++++++++--------- .../run-pass/borrowck-field-sensitivity.rs | 31 +++++++++++-------- 2 files changed, 33 insertions(+), 27 deletions(-) diff --git a/src/test/compile-fail/borrowck-field-sensitivity.rs b/src/test/compile-fail/borrowck-field-sensitivity.rs index 9a0d81e733208..2fa9067af549a 100644 --- a/src/test/compile-fail/borrowck-field-sensitivity.rs +++ b/src/test/compile-fail/borrowck-field-sensitivity.rs @@ -10,8 +10,6 @@ struct A { a: int, b: Box } -fn borrow(_: &T) { } - fn deref_after_move() { let x = A { a: 1, b: box 2 }; drop(x.b); @@ -27,35 +25,37 @@ fn deref_after_fu_move() { fn borrow_after_move() { let x = A { a: 1, b: box 2 }; drop(x.b); - borrow(&x.b); //~ ERROR use of moved value: `x.b` + let p = &x.b; //~ ERROR use of moved value: `x.b` + drop(**p); } fn borrow_after_fu_move() { let x = A { a: 1, b: box 2 }; let _y = A { a: 3, .. x }; - borrow(&x.b); //~ ERROR use of moved value: `x.b` + let p = &x.b; //~ ERROR use of moved value: `x.b` + drop(**p); } fn move_after_borrow() { let x = A { a: 1, b: box 2 }; - let y = &x.b; + let p = &x.b; drop(x.b); //~ ERROR cannot move out of `x.b` because it is borrowed - borrow(&*y); + drop(**p); } fn fu_move_after_borrow() { let x = A { a: 1, b: box 2 }; - let y = &x.b; - let _z = A { a: 3, .. x }; //~ ERROR cannot move out of `x.b` because it is borrowed - borrow(&*y); + let p = &x.b; + let _y = A { a: 3, .. x }; //~ ERROR cannot move out of `x.b` because it is borrowed + drop(**p); } fn mut_borrow_after_mut_borrow() { let mut x = A { a: 1, b: box 2 }; - let y = &mut x.a; - let z = &mut x.a; //~ ERROR cannot borrow `x.a` as mutable more than once at a time - drop(*y); - drop(*z); + let p = &mut x.a; + let q = &mut x.a; //~ ERROR cannot borrow `x.a` as mutable more than once at a time + drop(*p); + drop(*q); } fn move_after_move() { @@ -107,7 +107,8 @@ fn copy_after_field_assign_after_uninit() { fn borrow_after_field_assign_after_uninit() { let mut x: A; x.a = 1; - borrow(&x.a); //~ ERROR use of possibly uninitialized variable: `x.a` + let p = &x.a; //~ ERROR use of possibly uninitialized variable: `x.a` + drop(*p); } fn move_after_field_assign_after_uninit() { diff --git a/src/test/run-pass/borrowck-field-sensitivity.rs b/src/test/run-pass/borrowck-field-sensitivity.rs index 2500ec764ebaa..a297300daf1b2 100644 --- a/src/test/run-pass/borrowck-field-sensitivity.rs +++ b/src/test/run-pass/borrowck-field-sensitivity.rs @@ -11,8 +11,6 @@ struct A { a: int, b: Box } struct B { a: Box, b: Box } -fn borrow(_: &T) { } - fn move_after_copy() { let x = A { a: 1, b: box 2 }; drop(x.a); @@ -64,21 +62,23 @@ fn fu_copy_after_fu_move() { fn borrow_after_move() { let x = A { a: 1, b: box 2 }; drop(x.b); - borrow(&x.a); + let p = &x.a; + drop(*p); } fn borrow_after_fu_move() { let x = A { a: 1, b: box 2 }; let _y = A { a: 3, .. x }; - borrow(&x.a); + let p = &x.a; + drop(*p); } fn mut_borrow_after_mut_borrow() { let mut x = A { a: 1, b: box 2 }; - let y = &mut x.a; - let z = &mut x.b; - drop(*y); - drop(**z); + let p = &mut x.a; + let q = &mut x.b; + drop(*p); + drop(**q); } fn move_after_move() { @@ -138,28 +138,32 @@ fn borrow_after_assign_after_move() { let mut x = A { a: 1, b: box 2 }; drop(x.b); x = A { a: 3, b: box 4 }; - borrow(&x.b); + let p = &x.b; + drop(**p); } fn borrow_after_assign_after_fu_move() { let mut x = A { a: 1, b: box 2 }; let _y = A { a: 3, .. x }; x = A { a: 3, b: box 4 }; - borrow(&x.b); + let p = &x.b; + drop(**p); } fn borrow_after_field_assign_after_move() { let mut x = A { a: 1, b: box 2 }; drop(x.b); x.b = box 3; - borrow(&x.b); + let p = &x.b; + drop(**p); } fn borrow_after_field_assign_after_fu_move() { let mut x = A { a: 1, b: box 2 }; let _y = A { a: 3, .. x }; x.b = box 3; - borrow(&x.b); + let p = &x.b; + drop(**p); } fn move_after_assign_after_move() { @@ -199,7 +203,8 @@ fn copy_after_assign_after_uninit() { fn borrow_after_assign_after_uninit() { let mut x: A; x = A { a: 1, b: box 2 }; - borrow(&x.a); + let p = &x.a; + drop(*p); } fn move_after_assign_after_uninit() {