`impl Trait` with multiple lifetimes imposes a strange lifetime requirement

[goffrie]

Consider the following code:

pub struct Store;
impl Store {
    fn scan<'a>(&'a self) -> Box<dyn Iterator<Item = u64> + 'a> { panic!() }
}
pub struct Transaction<'a> {
    kv: &'a Store,
    reads: Vec<u64>,
}

impl<'a> Transaction<'a> {
    pub fn scan(&mut self) -> impl Iterator<Item = u64> + 'a + '_ {
        let iter = self.kv.scan();
        iter.map(move |k| {
            self.reads.push(k);
            k
        })
    }
}

Compiling with #![feature(nll)] yields the following error:

error: lifetime may not live long enough
  --> src/lib.rs:24:9
   |
18 |   impl<'a> Transaction<'a> {
   |        -- lifetime `'a` defined here
19 |       pub fn scan(&mut self) ->
   |                   - let's call the lifetime of this reference `'1`
...
24 | /         iter.map(move |k| {
25 | |             self.reads.push(k);
26 | |             k
27 | |         })
   | |__________^ returning this value requires that `'1` must outlive `'a`

error: aborting due to previous error

That is, it's requiring that the reference to Transaction outlive 'a. Unfortunately, it doesn't explain at all why that requirement was imposed.

Also, just returning + '_ complains:

error[E0700]: hidden type for `impl Trait` captures lifetime that does not appear in bounds
  --> src/lib.rs:20:9
   |
20 |         impl Iterator<Item = u64> + '_
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: hidden type `std::iter::Map<std::boxed::Box<dyn std::iter::Iterator<Item = u64>>, [closure@src/lib.rs:24:18: 27:10 self:&mut Transaction<'a>]>` captures the lifetime 'a as defined on the impl at 18:6
  --> src/lib.rs:18:6
   |
18 | impl<'a> Transaction<'a> {
   |      ^^

This is odd to me because if we return Box<dyn Iterator<Item = u64> + '_>, everything works fine (and nobody complains about 'a). Furthermore, the equivalent to the impl Trait using an explicit existential type TransactionScan<'a, 'b>: Iterator<Item = u64>; works fine as well.

This may be related to/a dupe of #49431, but the errors produced are different so I'm not sure.

[estebank]

Would using changing Transaction::scan to pub fn scan(&'a mut self) work for you?

[goffrie]

That makes the function compile, but it makes it quite unuseful for the caller: it means that any caller of scan() is committing to the Transaction being borrowed for as long as the lifetime of the Store reference within. For example, a function like

fn user(kv: &Store) {
    let mut tx = Transaction { kv, reads: vec![] };
    tx.scan().for_each(|x| println!("{:?}", x));
    tx.scan().for_each(|x| println!("{:?}", x));
}

fails to compile under that signature of fn scan:

error[E0499]: cannot borrow `tx` as mutable more than once at a time
  --> src/lib.rs:42:5
   |
41 |     tx.scan().for_each(|x| println!("{:?}", x));
   |     -- first mutable borrow occurs here
42 |     tx.scan().for_each(|x| println!("{:?}", x));
   |     ^^
   |     |
   |     second mutable borrow occurs here
   |     first borrow later used here

error: aborting due to previous error

(Also the error message here isn't great either - "first borrow later used here" isn't really pointing at the right thing because there isn't a later use of the mutable borrow, it's only required by the types.)

[kennytm]

Related: #66551.

You could workaround using the Captures trait.

pub trait Captures<U: ?Sized> {}
impl<U: ?Sized, T: ?Sized> Captures<U> for T {}

impl<'a> Transaction<'a> {
    pub fn scan(&mut self) -> impl Iterator<Item = u64> + Captures<&'a Store> + '_ {
        ...
    }
}

(untagging A-iterators, the issue is not an issue of iterators)