Error code E0772

Note: this error code is no longer emitted by the compiler.

A trait object has some specific lifetime '1, but it was used in a way that requires it to have a 'static lifetime.

Example of erroneous code:

#![allow(unused)]
fn main() {
trait BooleanLike {}
trait Person {}

impl BooleanLike for bool {}

impl dyn Person {
    fn is_cool(&self) -> bool {
        // hey you, you're pretty cool
        true
    }
}

fn get_is_cool<'p>(person: &'p dyn Person) -> impl BooleanLike {
    // error: `person` has an anonymous lifetime `'p` but calling
    //        `print_cool_fn` introduces an implicit `'static` lifetime
    //        requirement
    person.is_cool()
}
}

The trait object person in the function get_is_cool, while already being behind a reference with lifetime 'p, also has it's own implicit lifetime, '2.

Lifetime '2 represents the data the trait object might hold inside, for example:

#![allow(unused)]
fn main() {
trait MyTrait {}

struct MyStruct<'a>(&'a i32);

impl<'a> MyTrait for MyStruct<'a> {}
}

With this scenario, if a trait object of dyn MyTrait + '2 was made from MyStruct<'a>, 'a must live as long, if not longer than '2. This allows the trait object's internal data to be accessed safely from any trait methods. This rule also goes for any lifetime any struct made into a trait object may have.

In the implementation for dyn Person, the '2 lifetime representing the internal data was omitted, meaning that the compiler inferred the lifetime 'static. As a result, the implementation's is_cool is inferred by the compiler to look like this:

#![allow(unused)]
fn main() {
trait Person {}

impl dyn Person {
fn is_cool<'a>(self: &'a (dyn Person + 'static)) -> bool {unimplemented!()}
}
}

While the get_is_cool function is inferred to look like this:

#![allow(unused)]
fn main() {
trait Person {}
trait BooleanLike {}

fn get_is_cool<'p, R: BooleanLike>(person: &'p (dyn Person + 'p)) -> R {
    unimplemented!()
}
}

Which brings us to the core of the problem; the assignment of type &'_ (dyn Person + '_) to type &'_ (dyn Person + 'static) is impossible.

Fixing it is as simple as being generic over lifetime '2, as to prevent the compiler from inferring it as 'static:

#![allow(unused)]
fn main() {
trait Person {}

impl<'d> dyn Person + 'd {/* ... */}

// This works too, and is more elegant:
//impl dyn Person + '_ {/* ... */}
}

See the [Rust Reference on Trait Object Lifetime Bounds][trait-objects] for more information on trait object lifetimes.