rustc fails to produce lifetime and closure related compiler error.

[mitchmindtree]

We ran into this in conrod, where one of the widgets would produce different behaviour depending on whether it was compiled in debug or release.

The related conrod issue is here.

This comment describes the strange behaviour more precisely.

This comment demonstrates the fix used.

@huonw and @Aatch helped to point out that the difference in behaviour seemed to be due to the fact that rustc was failing to produce an error relating to the lifetimes of the demo, col and row values.

@Aatch shared a simplified example of what error we should have received here.

Edit: I should mention, this bug was found in:

• rustc 1.4.0 (8ab8581f6 2015-10-27)
• rustc 1.6.0-nightly (5b4986fa5 2015-11-08)
• rustc 1.5.0-beta.2 (b0f440163 2015-10-28)

on both windows and osx.

[Aatch]

I'm looking into this, trying to get a reasonably accurate reproduction and have come across this:

fn main() {
    let x = Some(|x: usize, y: usize| {
        |t: bool| if t { x } else { y }
    });

    // If the following line is uncommented, it doesn't compile
    //use_(x);
}

fn use_<G, F: FnMut(usize, usize) -> G>(f: Option<F>) {
    if let Some(mut f) = f {
        let _ = f(1, 2);
    }
}

https://play.rust-lang.org/?gist=b4a25867408e0056c8f3&version=stable

Which I believe is related.

[Aatch]

Woo! Took me a while, but here is a minimal(-ish) reproduction (while still being similar to the original example):

struct WrapA<F>(Option<F>);

impl<F> WrapA<F> {
    fn new() -> WrapA<F> {
        WrapA(None)
    }
    fn set(mut self, f: F) -> Self {
        self.0 = Some(f);
        self
    }
}

struct WrapB<F>(Option<F>);

impl<F> WrapB<F> {
    fn new() -> WrapB<F> {
        WrapB(None)
    }
    fn set(mut self, f: F) -> Self {
        self.0 = Some(f);
        self
    }
}

trait DoStuff : Sized {
    fn handle(self);
}

impl<F, T> DoStuff for WrapA<F> 
where F: FnMut(usize, usize) -> T, T: DoStuff {
    fn handle(mut self) {
        if let Some(ref mut f) = self.0 {
            let x = f(1, 2);
            let _foo = [0usize; 16];
            x.handle();
        }
    }
}

impl<F> DoStuff for WrapB<F> where F: FnMut(bool) -> usize {
    fn handle(mut self) {
        if let Some(ref mut f) = self.0 {
            println!("{}", f(true));
        }
    }
}

impl<F, T> WrapA<F> 
where F: FnMut(usize, usize) -> T, T: DoStuff {
    fn handle_ref(&mut self) {
        if let Some(ref mut f) = self.0 {
            let x = f(1, 2);
        }
    }
}

fn main() {
    let mut w = WrapA::new().set(|x: usize, y: usize| {
        WrapB::new().set(|t: bool| if t { x } else { y })
    })
    w.handle(); // This works
    // w.handle_ref(); // This doesn't
}

https://play.rust-lang.org/?gist=330b4ee92fecd1c8f499&version=stable

I think the move of the wrapping type has something to do with it, given that handle_ref doesn't work, while handle does.

Nope, just double-checked and it's actually inherent vs. trait methods. Making an identical handle method on WrapA directly works (as in, it causes the expected error) just fine. No idea why that would be the case though.

[Aatch]

I decided to go back to my simple case:

fn main() {
    let _x = |x: usize, y: usize| {
        |t: bool| if t { x } else { y }
    };

This compiles (and probably shouldn't), while the following doesn't (which is expected):

fn main() {
    let _x = |x: usize, y: usize| {
        let x = x;
        let y = y;
        |t: bool| if t { x } else { y }
    };

This suggests to me that the lifetimes associated with the x and y arguments are slightly too long.

Also /cc @rust-lang/compiler

[nikomatsakis]

agreed, seems wrong. sigh.

[nikomatsakis]

triage: P-high

[arielb1]

The issue is that:
* Closure signatures are not required to be well-formed.
* That would not be regularly a problem, as regions in closure signatures are supposed to always outlive the closure.
* However, parameters are regarded as being "outside" the closure, so they pass this check.

I am not sure of the best way to fix this. Maybe add an actual "root" region wrapping a closure, instead of using the DestructionScope?