moved renamed docs formatted | last-use-is-capture.rs

Author: Kivooeo

tests/ui/closures/closure-capture-after-clone.rs

@@ -0,0 +1,39 @@
+//! Regression test for issue #1399
+//!
+//! This test ensures that when a variable is used (via clone) and then later
+//! captured by a closure, the last-use analyzer doesn't incorrectly optimize
+//! the earlier use as a "last use" and perform an invalid move.
+//!
+//! The sequence being tested:
+//! 1. Create variable `k`
+//! 2. Use `k.clone()` for some purpose
+//! 3. Later capture `k` in a closure
+//!
+//! The analyzer must not treat step 2 as the "last use" since step 3 needs `k`.
+//!
+//! See: https://github.com/rust-lang/rust/issues/1399
+
+//@ run-pass
+
+struct A {
+    _a: Box<isize>
+}
+
+pub fn main() {
+    fn invoke<F>(f: F)
+    where
+        F: FnOnce()
+    {
+        f();
+    }
+
+    let k: Box<_> = 22.into();
+
+    // This clone should NOT be treated as "last use" of k
+    // even though k is not used again until the closure
+    let _u = A { _a: k.clone() };
+
+    // Here k is actually captured by the closure
+    // The last-use analyzer must have accounted for this when processing the clone above
+    invoke(|| println!("{}", k.clone()));
+}

tests/ui/closures/closure-last-use-move.rs

@@ -9,17 +9,17 @@
 
 //@ run-pass
 
-fn apply<T, F>(s: String, mut f: F) -> T 
-where 
-    F: FnMut(String) -> T 
+fn apply<T, F>(s: String, mut f: F) -> T
+where
+    F: FnMut(String) -> T
 {
-    fn g<T, F>(s: String, mut f: F) -> T 
-    where 
-        F: FnMut(String) -> T 
+    fn g<T, F>(s: String, mut f: F) -> T
+    where
+        F: FnMut(String) -> T
     {
         f(s)
     }
-    
+
     g(s, |v| {
         let r = f(v);
         r // This should be a move, not requiring copy

tests/ui/closures/closure-upvar-last-use-analysis.rs

@@ -15,15 +15,15 @@ struct A {
 
 fn foo() -> Box<dyn FnMut() -> isize + 'static> {
     let k: Box<_> = Box::new(22);
-    
-    // This use of k.clone() should not be treated as a "last use" 
+
+    // This use of k.clone() should not be treated as a "last use"
     // even though the closure below doesn't actually capture k
     let _u = A { _a: k.clone() };
-    
+
     // The closure doesn't actually use k, but the analyzer needs to handle
     // the potential capture scenario correctly
     let result = || 22;
-    
+
     Box::new(result)
 }