Temporary does not live long enough in let chains

[Alexendoo]

I tried this code, playground:

#![feature(let_chains)]

use syn::{Attribute, Meta};

fn f(attr: &Attribute) -> bool {
    if let Meta::NameValue(name_value) = attr.parse_meta().ok().unwrap()
        && let path_idents = name_value.path.segments.iter()
        /* other stuff */
    {
        
    }
    
    true
}

I expected to see this happen: code compiles

Instead, this happened: errors due to name_value.path.segments does not live long enough

It compiles when expressed as nested ifs, playground:

#![feature(let_chains)]

use syn::{Attribute, Meta};

fn f(attr: &Attribute) -> bool {
    if let Meta::NameValue(name_value) = attr.parse_meta().ok().unwrap() {
        if let path_idents = name_value.path.segments.iter() {}
    }

    true
}

The code compiled previously, but no longer does after #103034 (confirmed with a cargo bisect-rustc)

cc @nathanwhit

[est31]

Minimized:

#![feature(let_chains)]

struct Pd<T>(std::marker::PhantomData<T>);

impl<T> Pd<T> {
    fn iter(&self) -> Iter<T> {
        todo!()
    }
}

pub struct Iter<'a, T: 'a> {
    inner: Box<dyn IterTrait<'a, T> + 'a>,
}

trait IterTrait<'a, T: 'a> {
    fn clone_box(&self) -> Box<dyn IterTrait<'a, T> + 'a>;
}

fn f(m: Option<Pd<()>>) -> bool {
    if let Some(n) = m
        && let it = n.iter()
        /* other stuff */
    {
        
    }
    
    true
}

A bit further minimized:

#![feature(let_chains)]

struct Pd;

impl Pd {
    fn it(&self) -> It {
        todo!()
    }
}

pub struct It<'a>(Box<dyn Tr<'a>>);

trait Tr<'a> {}

fn f(m: Option<Pd>) {
    if let Some(n) = m && let it = n.iter() {};
}

[WaffleLapkin]

Even more minimized:

#![feature(let_chains)]
#![allow(irrefutable_let_patterns)]

fn it(_: &()) -> Box<dyn Tr<'_>> { todo!() }

trait Tr<'a> {}

fn f() {
    if let n = () && let _ = it(&n) {};
}

error[[E0597]](https://doc.rust-lang.org/nightly/error-index.html#E0597): `n` does not live long enough
 --> src/lib.rs:9:33
  |
9 |     if let n = () && let _ = it(&n) {};
  |                              ---^^-  -- ... and the borrow might be used here, when that temporary is dropped and runs the destructor for type `Box<dyn Tr<'_>>`
  |                              |  |    |
  |                              |  |    `n` dropped here while still borrowed
  |                              |  borrowed value does not live long enough
  |                              a temporary with access to the borrow is created here ...

[play]

---

Weirdly, I couldn't replace Box<dyn Tr<'a>> with anything else, I thought that it's just significant Drop & invariant lifetime 'a, but something like (String, fn(&'a ()) -> &'a ()) compiles, so I'm not sure what's going on.

[alercah]

Box's drop is actually hard-coded magic, so it might be unique to it.

[est31]

Good point about the lang item. I've tried it with Arc and Vec, it seems to fail for those too.

This also still reproduces:

#![feature(let_chains)]
#![allow(irrefutable_let_patterns)]

struct B<T: ?Sized> { _t: std::marker::PhantomData<T>, }

impl<T: ?Sized> std::ops::Drop for B<T> {
    fn drop(&mut self) {}
}

fn it(_: &()) -> B<dyn Tr<'_>> { todo!() }

trait Tr<'a> {}

fn f() {
    if let n = () && let _ = it(&n) {};
}

[nathanwhit]

This reproduces as well:

#![feature(let_chains)]
#![allow(irrefutable_let_patterns)]

struct B<'a>(&'a ());

impl<'a> std::ops::Drop for B<'a> {
    fn drop(&mut self) {}
}

fn f() {
    if let n = () && let _ = B(&n) {};
}

If you remove the Drop impl it compiles without error.

[WaffleLapkin]

The reason why Box<&'a ()> / Vec<&'a ()> don't work is probably because of #[may_dangle].

[est31]

There is no #[may_dangle] in the two last snippets, so I think it's not because of it.

[WaffleLapkin]

@est31 that's the point? @nathanwhit's example can use &'a () because the drop doesn't have #[may_dangle]. Arc has #[may_dangle], so Arc<&'a ()> does not reproduce the issue (you need a dyn Trait because it's possibly drop and has the lifetime).

[est31]

Good point, you are right about #[may_dangle] I think. If you remove the unsafe from and #[may_dangle] from here it fails again (but works right now):

#![feature(dropck_eyepatch)]
#![feature(let_chains)]
#![allow(irrefutable_let_patterns)]

struct B<T: ?Sized> { _t: *const T, }

unsafe impl<#[may_dangle] T: ?Sized> std::ops::Drop for B<T> {
    fn drop(&mut self) {}
}

fn it(_: &()) -> B<&()> { todo!() }

trait Tr<'a> {}

fn f() {
    if let n = () && let _ = it(&n) {};
}

[WiSaGaN]

Does this still block the stabilization of let chains?

[est31]

@WiSaGaN it would probably be very useful for this issue to get input by a borrow checking expert on whether this issue is fixable without doing breaking changes, and whether a fix is easy/feasible, or hard. Also, there are plans to rewrite large parts of let chains.

[est31]

As for your question: I wouldn't delay let chains for this indefinitely, esp as there is limited progress, but it would be sad that "there was not enough attention from the right people on this" is the reason why some issue can't get fixed indefinitely.

Atm there are also other blockers too like #104843 and #104893. Especially latter would greatly benefit from input from third parties: try out let chains in your own code, and report bugs you find.

[est31]

This doesn't reproduce on edition 2024 any more, while still reproducing on edition 2021. I would say it's fixed by if let rescoping (#124085).

I've tried both the "a bit further minimized" snippet as well as the snippet right below by @WaffleLapkin.

As to the original snippet provided by @Alexendoo , same behaviour there, although note that latest syn (v1.0.109) does not reproduce the issue while an older version like 1.0.80 reproduces it.

I suppose this can be closed now once we have a test for it in the testsuite.