Transmuting the same trait object with different lifetimes

[Darksonn]

Consider the following situation:

• You have an Box<dyn SomeTrait + 'a>
• You transmute it to a Box<dyn SomeTrait + 'static>

Is this transmute UB, assuming you actually destroy the box before the end of the lifetime 'a? It is a transmute that I see people do relatively often.

Similarly for &dyn SomeTrait and &mut dyn SomeTrait.

[bjorn3]

Transmuting &dyn SomeTrait to &mut dyn SomeTrait is UB as far as I know. Transmuting lifetimes is not.

[RalfJung]

I don't think we currently allow any kind of transmutes on dyn Trait. So this is not UB but also not guaranteed to give a reasonable result; it exploits unspecified implementation details (akin to transmuting repr(Rust) structs).

But this seems like a rather reasonable one, assuming the underlying data is indeed only accessed during the lifetime 'a.

[Darksonn]

@bjorn3 Right. What I meant was &dyn SomeTrait + 'a → &dyn SomeTrait + 'static and similarly for mutable references.

@RalfJung "So this is not UB"? Would exploiting unspecified implementation details not be UB?

[RalfJung]

Would exploiting unspecified implementation details not be UB?

No, not if you guessed those details correctly ;) . UB is documented at https://doc.rust-lang.org/reference/behavior-considered-undefined.html.
I might be language lawyering here, but I think this is an important distinction. Exploiting unspecified implementation details can easily lead to UB if you get them wrong or if they change (which they can any time without announcement, since they are unspecified), but if you happen to get them right, your code doesn't have UB. It's still a bug and outside the realms of what Rust guarantees, but it's distinct from UB.