confusing error message around trait object bound

[nikomatsakis]

This example:

#![feature(in_band_lifetimes)]
#![feature(nll)]

trait DebugWith<Cx: ?Sized> {
    fn debug_with(&'me self, cx: &'me Cx) -> DebugCxPair<'me, Self, Cx> {
        DebugCxPair { value: self, cx }
    }
    
    fn fmt_with(&self, cx: &Cx, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result;
}

struct DebugCxPair<'me, Value: ?Sized, Cx: ?Sized>
where
    Value: DebugWith<Cx>,
{
    value: &'me Value,
    cx: &'me Cx,
}

trait DebugContext { }

struct Foo {
    bar: Bar
}

impl DebugWith<dyn DebugContext> for Foo {
    fn fmt_with(&self, cx: &dyn DebugContext, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let Foo { bar } = self;
        bar.debug_with(cx);
        Ok(())
    }
}

struct Bar { }

impl DebugWith<dyn DebugContext> for Bar {
    fn fmt_with(&self, cx: &dyn DebugContext, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Ok(())
    }
}

fn main() { }

gives this error:

error: unsatisfied lifetime constraints
  --> src/main.rs:29:9
   |
27 |     fn fmt_with(&self, cx: &dyn DebugContext, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   |                 -          - let's call the lifetime of this reference `'1`
   |                 |
   |                 let's call the lifetime of this reference `'2`
28 |         let Foo { bar } = self;
29 |         bar.debug_with(cx);
   |         ^^^^^^^^^^^^^^^^^^ argument requires that `'1` must outlive `'2`

It took me some time to puzzle out what was happening here:

• cx: &dyn DebugContext expands to &'a dyn (DebugContext + 'a)
• the default from the impl however is dyn (DebugContext + 'static)
• the impl method is accepted because it is more general than the trait definition
• but it fails to recursively invoke

The error message without NLL, of course, is also not very illuminating.

[matthewjasper]

Assigning myself to bookmark.

[estebank]

the default from the impl however is dyn (DebugContext + 'static)

This seems to be a persistent ergonomics wart where traits get evaluated to 'static (happens as well with returning &(impl Trait) and others I can't remember now) where it isn't expected. It is a bit sad, and we can improve the diagnostic errors, but I'm worried we'll be unable to preempt all the cases from being caught by accurate diagnostics, pushing people away from deeply nested structures. Maybe that is for the best, though.

[pnkfelix]

I just want to note that the use of #![feature(in_band_lifetimes)] is, I think, a red herring in terms of the complaint about the diagnostic here.

That is, I get the exact same diagnostic even if I add an explicit <'me> binder to the fn debug_with method, and then one can remove the #![feature(in_band_lifetimes)].

This is relevant because it means that if that feature is a red herring, then this bug may be relevant to the 2018 edition.

[pnkfelix]

discussed with @nikomatsakis . We agreed this is not a blocker for 2018 edition. Tagging with NLL-deferred so it does not clog up our triage process.

[pnkfelix]

I forgot to actual test how migration-mode (enabled for the 2018 edition) compares to #![feature(nll)].

Details

Current (nightly) 2018 edition output (play):

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
  --> src/main.rs:26:24
   |
26 |         bar.debug_with(cx);
   |                        ^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #2 defined on the method body at 24:5...
  --> src/main.rs:24:5
   |
24 | /     fn fmt_with(&self, cx: &dyn DebugContext, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
25 | |         let Foo { bar } = self;
26 | |         bar.debug_with(cx);
27 | |         Ok(())
28 | |     }
   | |_____^
note: ...so that the declared lifetime parameter bounds are satisfied
  --> src/main.rs:26:24
   |
26 |         bar.debug_with(cx);
   |                        ^^
   = note: but, the lifetime must be valid for the static lifetime...
   = note: ...so that the expression is assignable:
           expected &(dyn DebugContext + 'static)
              found &dyn DebugContext

error: aborting due to previous error

Current (nightly) output with #![feature(nll)] (play):

error: lifetime may not live long enough
  --> src/main.rs:28:24
   |
26 |     fn fmt_with(&self, cx: &dyn DebugContext, _fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
   |                            - let's call the lifetime of this reference `'1`
27 |         let Foo { bar } = self;
28 |         bar.debug_with(cx);
   |                        ^^ cast requires that `'1` must outlive `'static`

[pnkfelix]

As for this week's triage, tagging this as P-medium priority.