Borrow checker false dropped while still borrowed

[letheed]

The following does not compile:

use std::ffi::OsString;
use std::io::{Result as IoResult};
use std::path::Path;

fn main() {
    let paths: Vec<OsString> = vec!["filename".into()];
// Switching these two lines appeases our lord and savior the borrow checker
    let f = std::fs::rename;
    let dests = paths.clone();
// ---------------------------
    let pairs = paths.iter().zip(dests.iter());
//                               ----- borrow occurs here
    foo(f, pairs);
}
// `dests` does not live long enough.
// ^ `dests` dropped here while still borrowed

fn foo<P, I>(f: fn(P, P) -> IoResult<()>, pairs: I)
    where P: AsRef<Path>,
          I: Iterator<Item=(P, P)>,
{
    for (src, dest) in pairs {
        let _ = f(src, dest);
    }
}

EDIT: simplified code.

[durka]

That's bizarre. Somehow the borrow checker thinks that f contains a borrow of dests. Removing the call to foo also eliminates the error.

[letheed]

Exactly. I have a hard time figuring out what is happening here; I'm not familiar with the compiler's internals.

[philipc]

Simplified a bit more:

fn main() {
    fn f<T>(_: T) {}
    let f = f;
    let v = 0;
    f(&v);
}

[Rufflewind]

Looking at @philipc's example, I believe the problem is that the type of the local variable f is actually the specialized type (since Rust does not support generics as first-class values). If you try to write out the specialized type, you get:

fn(&'a i32)

for some unknown 'a. The problem is that the presence of 'a affects not just the argument but also the function pointer itself, so the function pointer cannot outlive 'a either.

If we could somehow specialize for<T> fn(T) as for<'a> fn(&'a i32) (is this sound?), then this could be worked around by giving the local variable f the correct type annotation.

[letheed]

@Rufflewind That was a long time ago but I remember trying to use for<'a> because I something like that, but to no avail.

[memoryruins]

Triage: now compiles on 2018 edition.
2015 errors:

error[E0597]: `dests` does not live long enough
  --> src/main.rs:11:34
   |
11 |     let pairs = paths.iter().zip(dests.iter());
   |                                  ^^^^^ borrowed value does not live long enough
...
14 | }
   | - `dests` dropped here while still borrowed
   |
   = note: values in a scope are dropped in the opposite order they are created

error: aborting due to previous error

rustc: 1.32.0