Match does not understand lifetimes of enum variants

[jamesmunns]

I tried this code:

use std::borrow::Cow;

enum Example<'a> {
    TotallyOwned{ foo: u32, bar: u32 },
    MaybeBorrowed(Cow<'a, [u8]>),
}

impl<'a> Example<'a> {
    fn to_owned(self) -> Example<'static> {
        match self {
            Example::MaybeBorrowed(p) => Example::MaybeBorrowed(Cow::Owned(p.into_owned())),
            
            // Doesn't work!
            a @ Example::TotallyOwned { .. } => a, //~ ERROR lifetime may not live long enough
            
            // Does work, but verbose!
            // Example::TotallyOwned { foo, bar } => Example::TotallyOwned { foo, bar }
        }
    }
}

I expected the match arm a @ Example::TotallyOwned { .. } => a to work, as this variant is completely owned.

Instead, I needed to completely destruct the enum variant, and create a new one, to "make Rust understand" I was creating a fully owned enum instance.

I can understand why this error exists: namely if I am returning a rebound instance of the original enum, it still is bound to the 'a lifetime, however in the case of the TotallyOwned variant, this lifetime is "meaningless", which (someday?) rustc may be able to see.

Since this is more of an "improvement request" kind of issue, let me know if there is a better place to open this, or if this is the sort of thing that would require an RFC.

Meta

This presents in the current stable (1.54.0), as well as the current nightly (2021-08-27), though is likely true for all versions

Backtrace

<backtrace>

[digama0]

This seems like something that needs an RFC to change, because justifying this expansion requires a to have something additional to its type to remember that it is actually of a particular variant. That is, at the point a is used it definitely has type Example<'a>, which does not coerce to Example<'static>, so in that sense this is "not a bug", and I'm not a fan of poking holes in the type system to accommodate tricks like this.

A thread on https://internals.rust-lang.org might be a good place to test the waters re: popular support for an RFC along these lines.

[samestep]

Ran into this today when trying to implement std::error::Error for a lexer; my Token<'a> enum has a few dozen variants but only one uses 'a, so this bug requires me to write out each token variant in my match in order to convert to Token<'static>.