Rust doesn't recognize that a borrow ends at the end of a loop

user_7223291 0
Viewed 138

In the following code, it seems like the rust compiler has a problem with a borrow being dropped at the end of the code's execution. Even if I wrap the for loop in brackets so it has it's own scope it doesn't seem to recognize that the borrow comes to an end.

use std::ops::RangeBounds;
use std::any::Any;

pub trait UpdateTables<T> {
    fn apply_first<'a>(&mut self, table: &'a mut T) -> Box<dyn Any + 'a>;
}

struct Drain<R>
where
    R: 'static + Clone + RangeBounds<usize>,
{
   pub r: R,
}
    
impl<T, R> UpdateTables<Vec<T>> for Drain<R>
where
    R: 'static + Clone + RangeBounds<usize>,
{
    fn apply_first<'a>(&mut self, table: &'a mut Vec<T>) -> Box<dyn Any + 'a> {
        Box::new(table.drain(self.r.clone()))
    }
}
    
fn main() {
    let mut v = vec![1, 2, 4, 5, 7, 8];
    let mut d = Drain {
        r: (1..),
    };
    
    println!("{:?}", &v);
    for i in d.apply_first(&mut v).downcast::<std::vec::Drain<'_, i32>>().unwrap() {
        println!("{:?}", i);
    }
    println!("{:?}", &v);
}

Compile error:

error[E0597]: `v` does not live long enough
  --> src/main.rs:32:28
   |
32 |     for i in d.apply_first(&mut v).downcast::<std::vec::Drain<'_, i32>>().unwrap() {
   |              --------------^^^^^^-
   |              |             |
   |              |             borrowed value does not live long enough
   |              argument requires that `v` is borrowed for `'static`
...
37 | }
   | - `v` dropped here while still borrowed

error[E0502]: cannot borrow `v` as immutable because it is also borrowed as mutable
  --> src/main.rs:36:22
   |
32 |     for i in d.apply_first(&mut v).downcast::<std::vec::Drain<'_, i32>>().unwrap() {
   |              ---------------------
   |              |             |
   |              |             mutable borrow occurs here
   |              argument requires that `v` is borrowed for `'static`
...
36 |     println!("{:?}", &v);
   |                      ^^ immutable borrow occurs here
borrow-checker rust
1 Answers

The loop is not the problem. The errors are the same in this reduced example:

use std::any::Any;

fn apply_first<'a, T>(table: &'a mut Vec<T>) -> Box<dyn Any + 'a> {
    Box::new(table.drain(1..))
}
    
fn main() {
    let mut v = vec![1, 2, 4, 5, 7, 8];
    let _ = apply_first(&mut v);
    println!("{:?}", &v);
}

error[E0597]: `v` does not live long enough
  --> src/main.rs:9:25
   |
9  |     let _ = apply_first(&mut v);
   |             ------------^^^^^^-
   |             |           |
   |             |           borrowed value does not live long enough
   |             argument requires that `v` is borrowed for `'static`
10 |     println!("{:?}", &v);
11 | }
   | - `v` dropped here while still borrowed

error[E0502]: cannot borrow `v` as immutable because it is also borrowed as mutable
  --> src/main.rs:10:22
   |
9  |     let _ = apply_first(&mut v);
   |             -------------------
   |             |           |
   |             |           mutable borrow occurs here
   |             argument requires that `v` is borrowed for `'static`
10 |     println!("{:?}", &v);
   |                      ^^ immutable borrow occurs here

The core issue is that Any only works for 'static types, so dyn Any + 'a is meaningless and implies that 'a: 'static. I do wish the compiler was a little more informative about where the 'static constraint was coming from, but I digress.

See also: Lifetime issue when using the Any trait to get references to structs containing references

user_21891300
Related