Better diagnostics for inappropriate lifetime from (large) match statement

[djc]

With this reduced example, I get a nice, specific error message:

use std::borrow::Cow;

enum Foo<'a> {
    Bar(Cow<'a, [u8]>),
    Baz(Cow<'a, [u8]>),
}

impl<'a> Foo<'a> {
    fn to_owned(&self) -> Foo<'static> {
        match self {
            Foo::Bar(x) => Foo::Bar(x.to_owned()),
            Foo::Baz(x) => Foo::Baz(x.to_owned()),
        }
    }
}

Error:

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
  --> src/lib.rs:10:15
   |
10 |         match self {
   |               ^^^^
   |
note: first, the lifetime cannot outlive the lifetime `'a` as defined on the impl at 8:6...
  --> src/lib.rs:8:6
   |
8  | impl<'a> Foo<'a> {
   |      ^^
note: ...so that the types are compatible
  --> src/lib.rs:10:15
   |
10 |         match self {
   |               ^^^^
   = note: expected `&Foo<'_>`
              found `&Foo<'a>`
   = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the expression is assignable
  --> src/lib.rs:11:28
   |
11 |             Foo::Bar(x) => Foo::Bar(x.to_owned()),
   |                            ^^^^^^^^^^^^^^^^^^^^^^
   = note: expected `Foo<'static>`
              found `Foo<'_>`

However, in this real world case (from rustls/rustls#685), the error message isn't as good:

    pub fn to_owned(&self) -> ClientExtension<'static> {
        use ClientExtension::*;
        match self {
            ECPointFormats(x) => ECPointFormats(x.clone()),
            NamedGroups(x) => NamedGroups(x.clone()),
            SignatureAlgorithms(x) => SignatureAlgorithms(x.clone()),
            ServerName(x) => ServerName(x.iter().map(|y| y.to_owned()).collect()),
            SessionTicketRequest => SessionTicketRequest,
            SessionTicketOffer(x) => SessionTicketOffer(x.to_owned()),
            Protocols(x) => Protocols(x.iter().map(|y| y.to_owned()).collect()),
            SupportedVersions(x) => SupportedVersions(x.clone()),
            KeyShare(x) => KeyShare(x.iter().map(|y| y.to_owned()).collect()),
            PresharedKeyModes(x) => PresharedKeyModes(x.clone()),
            PresharedKey(x) => PresharedKey(x.to_owned()),
            Cookie(x) => Cookie(x.to_owned()),
            ExtendedMasterSecretRequest => ExtendedMasterSecretRequest,
            CertificateStatusRequest(x) => CertificateStatusRequest(x.to_owned()),
            SignedCertificateTimestampRequest => SignedCertificateTimestampRequest,
            TransportParameters(x) => TransportParameters(x.to_owned()),
            TransportParametersDraft(x) => TransportParametersDraft(x.to_owned()),
            EarlyData => EarlyData,
            Unknown(r) => Unknown(r.to_owned()),
        }
    }

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
   --> rustls/src/msgs/handshake.rs:698:15
    |
698 |         match self {
    |               ^^^^
    |
note: first, the lifetime cannot outlive the lifetime `'a` as defined on the impl at 670:6...
   --> rustls/src/msgs/handshake.rs:670:6
    |
670 | impl<'a> ClientExtension<'a> {
    |      ^^
note: ...so that the types are compatible
   --> rustls/src/msgs/handshake.rs:698:15
    |
698 |         match self {
    |               ^^^^
    = note: expected `&ClientExtension<'_>`
               found `&ClientExtension<'a>`
    = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the expression is assignable
   --> rustls/src/msgs/handshake.rs:698:9
    |
698 | /         match self {
699 | |             ECPointFormats(x) => ECPointFormats(x.clone()),
700 | |             NamedGroups(x) => NamedGroups(x.clone()),
701 | |             SignatureAlgorithms(x) => SignatureAlgorithms(x.clone()),
...   |
717 | |             Unknown(r) => Unknown(r.to_owned()),
718 | |         }
    | |_________^
    = note: expected `ClientExtension<'static>`
               found `ClientExtension<'_>`

Note that this error does not point to any specific arm, and leaves me to figure out which of the match arms had incorrect lifetimes. In this case, I happened to know which arms were at fault, but in an earlier instance I ended up bisecting the match arms by copy/pasting until I figured out which ones were incorrect.

This happened for me with rustc 1.52.0, but I see the same behavior with a nightly from 2021-04-24.

[FabianWolff]

Here is a smaller example that reproduces the problem. This gives an error for the problematic match arm:

enum Foo<'a> {
    Bar,
    Baz(&'a str),
}

impl<'a> Foo<'a> {
    fn to_owned(&self) -> Foo<'static> {
        use Foo::*;
        match self {
            Baz(x) => Baz(x.to_owned()),
            Bar => Bar,
        }
    }
}

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
  --> src/lib.rs:9:15
   |
9  |         match self {
   |               ^^^^
   |
note: first, the lifetime cannot outlive the lifetime `'a` as defined on the impl at 6:6...
  --> src/lib.rs:6:6
   |
6  | impl<'a> Foo<'a> {
   |      ^^
note: ...so that the types are compatible
  --> src/lib.rs:9:15
   |
9  |         match self {
   |               ^^^^
   = note: expected `&Foo<'_>`
              found `&Foo<'a>`
   = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the expression is assignable
  --> src/lib.rs:10:23
   |
10 |             Baz(x) => Baz(x.to_owned()),
   |                       ^^^^^^^^^^^^^^^^^
   = note: expected `Foo<'static>`
              found `Foo<'_>`

However, if we switch the two match arms, the error message points to the entire match expression, not just the specific arm that causes the issue:

enum Foo<'a> {
    Bar,
    Baz(&'a str),
}

impl<'a> Foo<'a> {
    fn to_owned(&self) -> Foo<'static> {
        use Foo::*;
        match self {
            Bar => Bar,
            Baz(x) => Baz(x.to_owned()),
        }
    }
}

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
  --> src/lib.rs:9:15
   |
9  |         match self {
   |               ^^^^
   |
note: first, the lifetime cannot outlive the lifetime `'a` as defined on the impl at 6:6...
  --> src/lib.rs:6:6
   |
6  | impl<'a> Foo<'a> {
   |      ^^
note: ...so that the types are compatible
  --> src/lib.rs:9:15
   |
9  |         match self {
   |               ^^^^
   = note: expected `&Foo<'_>`
              found `&Foo<'a>`
   = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the expression is assignable
  --> src/lib.rs:9:9
   |
9  | /         match self {
10 | |             Bar => Bar,
11 | |             Baz(x) => Baz(x.to_owned()),
12 | |         }
   | |_________^
   = note: expected `Foo<'static>`
              found `Foo<'_>`

[djc]

Thanks for that!

[ennis]

I encountered a similar problem with the following code, using the cssparser crate:

impl<'a> Line<'a> {
    pub(crate) fn parse_css<'b>(input: &mut Parser<'a, 'b>) -> Result<Line<'a>, ParseError<'a, ()>> {
        let first = input.next()?;
        let second = input.try_parse(|input| input.next());
        match (first, second) {
            // ... omitted for brevity ...
            (Token::Ident(id), Err(_)) => Ok(Line::Named(&**id)),  // *** lifetime error is here
            _ => Err(input.new_custom_error(())),
        }
    }
}

in this case, the code block pointed by the error message is the whole match expression:

Diagnostics

error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
   --> C:\Users\Alexandre\devel\kyute\kyute\src\widget\grid\mod.rs:271:27
    |
271 |         let first = input.next()?;
    |                           ^^^^
    |
note: first, the lifetime cannot outlive the lifetime `'b` as defined here...
   --> C:\Users\Alexandre\devel\kyute\kyute\src\widget\grid\mod.rs:270:29
    |
270 |     pub(crate) fn parse_css<'b>(input: &mut Parser<'a, 'b>) -> Result<Line<'a>, ParseError<'a, ()>> {
    |                             ^^
note: ...so that the type `cssparser::Parser<'a, 'b>` is not borrowed for too long
   --> C:\Users\Alexandre\devel\kyute\kyute\src\widget\grid\mod.rs:271:21
    |
271 |         let first = input.next()?;
    |                     ^^^^^
note: but, the lifetime must be valid for the lifetime `'a` as defined here...
   --> C:\Users\Alexandre\devel\kyute\kyute\src\widget\grid\mod.rs:268:6
    |
268 | impl<'a> Line<'a> {
    |      ^^
note: ...so that the types are compatible
   --> C:\Users\Alexandre\devel\kyute\kyute\src\widget\grid\mod.rs:273:9
    |
273 | /         match (first, second) {
274 | |             // auto
275 | |             (Token::Ident(id), Err(_)) if &**id == "auto" => Ok(Line::Auto),
276 | |             // span N
...   |
308 | |             _ => Err(input.new_custom_error(())),
309 | |         }
    | |_________^
    = note: expected `std::result::Result<grid::Line<'a>, ParseError<'a, _>>`
               found `std::result::Result<grid::Line<'_>, ParseError<'_, _>>`

But if I wrap the offending match arm in a block, like so:

(Token::Ident(id), Err(_)) => { Ok(Line::Named(&**id)) }, // *** lifetime error is here

then the diagnostic points to the actual offending expression:

Diagnostics

error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
   --> C:\Users\Alexandre\devel\kyute\kyute\src\widget\grid\mod.rs:271:27
    |
271 |         let first = input.next()?;
    |                           ^^^^
    |
note: first, the lifetime cannot outlive the lifetime `'b` as defined here...
   --> C:\Users\Alexandre\devel\kyute\kyute\src\widget\grid\mod.rs:270:29
    |
270 |     pub(crate) fn parse_css<'b>(input: &mut Parser<'a, 'b>) -> Result<Line<'a>, ParseError<'a, ()>> {
    |                             ^^
note: ...so that the type `cssparser::Parser<'a, 'b>` is not borrowed for too long
   --> C:\Users\Alexandre\devel\kyute\kyute\src\widget\grid\mod.rs:271:21
    |
271 |         let first = input.next()?;
    |                     ^^^^^
note: but, the lifetime must be valid for the lifetime `'a` as defined here...
   --> C:\Users\Alexandre\devel\kyute\kyute\src\widget\grid\mod.rs:268:6
    |
268 | impl<'a> Line<'a> {
    |      ^^
note: ...so that the types are compatible
   --> C:\Users\Alexandre\devel\kyute\kyute\src\widget\grid\mod.rs:309:17
    |
309 |                 Ok(Line::Named(&**id))
    |                 ^^^^^^^^^^^^^^^^^^^^^^
    = note: expected `std::result::Result<grid::Line<'a>, ParseError<'a, _>>`
               found `std::result::Result<grid::Line<'_>, ParseError<'_, _>>`