Cannot coerce dyn Trait<'short> + 'long to dyn Trait<'long> + 'long

[Jules-Bertholet]

I tried this code:

trait Trait<'a> {}

fn convert<'short, 'long: 'short>(
    obj: Box<dyn Trait<'short> + 'long>,
) -> Box<dyn Trait<'long> + 'long> {
    obj
}

I expected to see this happen: It compiles. The concrete type of the dyn Trait<'short> + 'long cannot mention 'short (as it lives for all of 'long), so it must implement Trait<'long> also.

Instead, this happened:

error: lifetime may not live long enough
 --> src/lib.rs:6:5
  |
3 | fn convert<'short, 'long: 'short>(
  |            ------  ----- lifetime `'long` defined here
  |            |
  |            lifetime `'short` defined here
...
6 |     obj
  |     ^^^ function was supposed to return data with lifetime `'long` but it is returning data with lifetime `'short`
  |
  = help: consider adding the following bound: `'short: 'long`

Meta

rustc --version:

1.86.0

@rustbot label A-lifetimes A-trait-objects T-types

[compiler-errors]

Is this suggesting that I should be able to turn a dyn Trait<'a, 'b> + 'static into a dyn Trait<'a, 'static> + 'static? If so, that's unsound:

trait Trait<'a, 'b> {
    fn turn(&self, x: &'a str) -> &'b str;
}

impl<'a> Trait<'a, 'a> for () {
    fn turn(&self, x: &'a str) -> &'a str {
        x
    }
}

/// Emulate the requested upcasting behavior.
///
/// For obvious reasons this is impl'd via unsafe.
fn upcast<'a, 'b>(x: Box<dyn Trait<'a, 'b> + 'static>) -> Box<dyn Trait<'a, 'static> + 'static> {
    unsafe { std::mem::transmute(x) }
}

fn longer<'a>(x: &'a str) -> &'static str {
    let o: Box<dyn Trait<'a, 'a>> = Box::new(());
    upcast(o).turn(x)
}

If this is a behavior that would only work for one lifetime for some reason, then it doesn't really feel principled.

[Jules-Bertholet]

That’s a good example, thanks! But you could turn dyn Trait<'a, 'b> + 'static into dyn Trait<'static, 'static> + 'static. So I suppose the generalization would be:

trait Trait<'a, 'b, 'c> {}

fn convert<'short, 'short2, 'long: 'short + 'short2, 'longer: 'long>(
    obj: Box<dyn Trait<'short, 'short2, 'longer> + 'long>,
) -> Box<dyn Trait<'long, 'long, 'longer> + 'long> {
    obj
}

All lifetime parameters not already known to outlive 'long have to be converted 'short → 'long at once.

[compiler-errors]

That doesn't seem like something we can implement given that the trait system doesn't know anything about lifetime relationships (especially so in NLL), and I'm not convinced the new strategy is sound either.

[QuineDot]

Even if it could be sound for safe code, unsafe code can rely on the invariance of trait parameters for soundness.

Example.

[compiler-errors]

I'm gonna close this b/c it doesn't seem actionable.

[Jules-Bertholet]

Even if it could be sound for safe code, unsafe code can rely on the invariance of trait parameters for soundness.

Example.

Nice example, thanks! @RalfJung I think this is another soundness conflict for rust-lang/unsafe-code-guidelines#379?

[RalfJung]

Hm, maybe? That issue was originally meant for two libraries conflicting with each other, this here is about a language feature... but I guess we already have other language features there.

[Jules-Bertholet]

That issue was originally meant for two libraries conflicting with each other, this here is about a language feature...

You could emulate the language feature with a library function that does a transmute.