Lifetime deduction and borrowing in generic functions (required for generic-tests)

Assume a simple trait which allows an object reference to be attached. I used String here to make the code a little bit simpler.

trait Attachable<'a> {
    fn new() -> Self;
    fn attach(&mut self, value: &'a String);
}

A simplistic implementation could look like:

struct SomeAttachable<'a> {
    id: Option<&'a String>,
}

impl<'a> Attachable<'a> for SomeAttachable<'a> {
    fn new() -> Self {
        Self { id: None }
    }
    fn attach(&mut self, value: &'a String) {
        self.id = Some(value)
    }
}

and using it works out of the box.

let mut object = SomeAttachable::new();
let value = "hello".to_string();
object.attach(&value);

But when this is put into a generic function where only the attachable type is provided it breaks.

fn do_stuff<'a, T: Attachable<'a>>() {
    let mut object = T::new();
    let value: String = "hello".to_string();
    object.attach(&value); // breaks here since value does not live long enough
}

I assume that the lifetime is detected when the function do_stuff is called and then value has a "wrong" lifetime requirement. How can I correct the lifetime issue in the implementation do_stuff.

Adjusting the function signature to:

fn do_stuff_with_argument<'a, T: Attachable<'a>>(value: &'a String) {
    let mut bla = T::new();
    bla.attach(&value);
}

would solve the problem since now the lifetime is detected correctly again since it is part of the input reference argument. But this wouldn't be a suitable solution for me. The do_stuff function shall handle all the logic inside the function without requiring any function arguments. Only generic arguments are allowed like lifetimes and types.

I assume that I may have to use Higher-Rank Trait Bounds and implement do_stuff like:

fn do_stuff<T>()
where
    T: for<'a> Attachable<'a>,
{
    let mut object = T::new();
    let value: String = "hello".to_string();
    object.attach(&value);
}

but this causes rust to complain that the implementation of Attachable is not generic enough for SomeAttachable.

To provide some context: I require this for unit tests based on the generic-test crate where the behavior of a trait is verified.

You can use a AttachableTag trait, with a generic associated type that gives you an Attachable<'a> for any 'a (you can also use the same trait and type, but I prefer it this way):

trait AttachableTag {
    type Attachable<'b>: Attachable<'b>;
}

trait Attachable<'a> {
    fn new() -> Self;
    fn attach(&mut self, value: &'a String);
}

struct SomeAttachableTag;

impl AttachableTag for SomeAttachableTag {
    type Attachable<'b> = SomeAttachable<'b>;
}

struct SomeAttachable<'a> {
    id: Option<&'a String>,
}

impl<'a> Attachable<'a> for SomeAttachable<'a> {
    fn new() -> Self {
        Self { id: None }
    }
    fn attach(&mut self, value: &'a String) {
        self.id = Some(value)
    }
}

fn do_stuff<T: AttachableTag>() {
    let mut object = T::Attachable::new();
    let value: String = "hello".to_string();
    object.attach(&value);
}

do_stuff::<SomeAttachableTag>();

However, this gives an error:

error[E0597]: `value` does not live long enough
  --> src/main.rs:32:19
   |
32 |     object.attach(&value);
   |                   ^^^^^^ borrowed value does not live long enough
33 | }
   | -
   | |
   | `value` dropped here while still borrowed
   | borrow might be used here, when `object` is dropped and runs the destructor for type `<T as AttachableTag>::Attachable<'_>`
   |
   = note: values in a scope are dropped in the opposite order they are defined

To fix that, move value's declaration before object:

fn do_stuff<T: AttachableTag>() {
    let value: String = "hello".to_string();
    let mut object = T::Attachable::new();
    object.attach(&value);
}