Call field's function and pass &self in Rust - rust

Question

I have a MainStruct which owns an instance of HelperStruct. I want to make a method that calls helper's method. But the helper's method really needs (immutable) access to MainStruct
struct MainStruct {
helper: HelperStruct,
}
impl MainStruct {
pub fn call_helper(&mut self, args) {
// &mut self because the_method changes inner state of HelperStruct
self.helper.the_method(self, args)
}
}
impl HelperStruct {
pub fn the_method(&mut self, owner: &MainStruct, args) {
owner.other_method();
}
}
With this setup, I'm getting
error[E0502]: cannot borrow `self.helper` as mutable because it is also borrowed as immutable
214 | self.helper.the_method(self, args)
| ^^^^^^^^^^^^----------^----^^^^^^^^^^^^^^^^^^^^^^
| | | |
| | | immutable borrow occurs here
| | immutable borrow later used by call
| mutable borrow occurs here
It is crucial that the MainStruct remains the primary interface for interaction with the functionality (so having Helper own Main isn't an option).
How should I restructure my code (or maybe use smart pointers?) so that I can interact with the owner from the inside of Helper?
Also, it is guaranteed that the_method() will only be called inside an instance of MainStruct.
Actual context:
The MainStruct is the Field of my game. The HelperStruct is the class that takes care of pathing, A* mostly. A* has a number of large arrays that store its state. After an A* pass only some of them need to be reinitialized (or otherwise cleaned).
I end up calling A* a lot of times, so I want to avoid fully reinitializing it for every pass. So I store it in Field, and only call reset() after a pass.
To path plan properly, A* needs to look at the Field (obstacles, etc). While the A* is going, it of course changes some of its own fields, so the_method, being actually
pub fn full_pathing(&mut self, field: &Field, source: (i32, i32), destination: (i32, i32))
needs to have a &mut self

Answer 1

You can make the_method an associated function, and have it only receive a &mut MainStruct. It will have to access itself through that reference:
struct MainStruct {
helper: HelperStruct,
}
impl MainStruct {
pub fn call_helper(&mut self, args) {
HelperStruct::the_method(self, args)
}
}
impl HelperStruct {
pub fn the_method(main: &mut MainStruct, args) {
main.other_method();
//Access helper like this:
main.helper.whatever();
}
}
Alternatively, if your two structs are so intertwined, you could combine them into a single struct.

Answer 2

You need to convince Rust that, whatever HelperStruct is doing with MainStruct, it's not going to try to also access itself through MainStruct, since that constitutes an immutable reference to something that you also have a mutable reference to.
Depending on the complexity and needs of HelperStruct, one option would be to swap a dummy HelperStruct value into MainStruct and then call the function on the (now-isolated) HelperStruct.
use std::mem::swap;
struct MainStruct {
helper: HelperStruct,
}
impl MainStruct {
pub fn call_helper(&mut self, args) {
let mut helper_struct = HelperStruct::default(); // Some dummy value
swap(&mut helper_struct, &mut self.helper);
helper_struct.the_method(self, args);
swap(&mut helper_struct, &mut self.helper);
}
}
This way, HelperStruct.the_method has immutable access to all of MainStruct except itself, which has been temporarily shimmed out. After we're done, we swap the values back and there's no harm done.

Answer 3

Passing self to the_method borrows helper immutably, but the method call itself also borrows it mutably. If you change the signature to
pub fn the_method(&self, owner: &MainStruct, args)
it should work. If you need the_method to take a mutable reference to self you'll need to think of restructuring your code.