Trouble understanding `self` escapes the method body here

I'm very new to Rust. I've been through the various books etc but I'm consistently having issues with code like the following.

This is a simple repro that follows the function prototype of a package I'm using

#[derive(Default)]
struct DoSomething {
    x: i32,
}

fn some_func(loader: impl FnOnce() + 'static) {}

impl DoSomething {
    async fn do_something(&mut self) {
        some_func(|| {
            self.x = 100;
        });
    }
}

I get a compiler error in the call to some_func

error[E0521]: borrowed data escapes outside of method
  --> src\main.rs:44:9
   |
43 |       async fn do_something(&mut self) {
   |                             ---------
   |                             |
   |                             `self` is a reference that is only valid in the method body
   |                             let's call the lifetime of this reference `'1`
44 | /         some_func(|| {
45 | |             self.x = 100;
46 | |         });
   | |          ^
   | |          |
   | |__________`self` escapes the method body here
   |            argument requires that `'1` must outlive `'static`

Now I get that because the closure captures the reference of self and combined with 'static on some_func, the borrow checker can't be sure that self will be valid when the closure is eventually executed. Is that correct?

Now the million dollar question. Whats the right way to do something like this?

For completeness, the package I'm using is called callback-future which allows me to turn a callback into a future. The full code I want to get working is:

    async fn some_async(&mut self) -> Result<String, i32> {
        CallbackFuture::new(|complete| {
            self.cb = Some(complete);
        })
        .await
    }

The idea is to store the complete Fn passed into the closure so I can execute when some later async workflows have completed.

Because the library requires a FnOnce bound by 'static, you must ensure that all references passed into the closure are also at least 'static. This is the easiest solution:

impl DoSomething {
    async do_something(&'static mut self) {
        some_func(|| self.x = 100);
    }
}

I recommend looking into a different crate, usually you have to leak memory to obtain a static reference.