Closure referring to a method of self: borrow error

Question

Here is the interesting part:

struct S1 {}

impl S1 {
    pub fn new() -> Self {
        S1 {}
    }

    pub fn foo<F>(&self, mut delegate: F) -> ()
    where
        F: FnMut() -> (),
    {
        delegate()
    }
}

struct S2 {
    s1: S1,
    done: bool,
}

impl S2 {
    pub fn new() -> Self {
        S2 {
            s1: S1::new(),
            done: false,
        }
    }

    fn actually_do_something(&mut self) -> () {
        self.done = true
    }

    pub fn do_something(&mut self) -> () {
        self.s1.foo(|| {
            self.actually_do_something();
        })
    }
}

The actual error generated is:

error[E0500]: closure requires unique access to `self` but `self.s1` is already borrowed
  --> src/main.rs:34:21
   |
34 |         self.s1.foo(|| {
   |         -------     ^^ closure construction occurs here
   |         |
   |         borrow occurs here
35 |             self.actually_do_something();
   |             ---- borrow occurs due to use of `self` in closure
36 |         })
   |          - borrow ends here

I understand why I get this error (having multiple overlapping mutable borrows of self), yet I can't find a proper way to solve it. Taking multiple deep references to my object here doesn't seem to be possible as I'm calling a self method directly.

Answer 1

A way of doing this is to destructure your struct. Here is a sample with your code:

pub fn do_something(&mut self) -> () {
    let &mut S2 { ref mut s1, ref mut done } = self;
    s1.foo(|| {
        *done = true;
    })
}

Playground