Today I got pissed with Rust’s infamous borrow checker. I know that it’s always the developers’s fault and that the borrow checker is always right. But I got a bit emotional with this one.
This is valid (1):
match opcode {
0x01 => {
let bytes = self.read_next_16bits(); // Requires mutable, since it changes internal state
self.ld(RegCode::BC, bytes); // Also requires mutable
},
// ... other cases
}
This is not valid (2):
match opcode {
0x01 => self.ld(RegCode::BC, self.read_next_16bits()),
}
The borrow checker is complaining with the following message: cannot borrow *self as mutable more than once at a time second mutable borrow occurs here
After searching around and asking members of the community, I got to this issue on GitHub that explains the issue pretty well. You cannot reference a second mutable
after the first lexically. But my problem is that the first reference should be resolved completely before the second is needed, and therefore shouldn’t be a problem to deference once you can the second method.
Here’s a poorly drawn stack:
STACK =>
1. main
1. read_next_16bits() <- Has mutable reference
2. main
1. main <- Receives mutable reference
1. ld() <- Has mutable reference
2. main
Theoretically, the call stack should be exactly the same on both scenarios. But when Rust desugars the code, &mut self
parameters are requested directly on the parameter list. Therefore the first call to the &mut self
happens for the second method to be called, and this is the main reason why this fails. Which is a bit frustrating in my opinion, because my code will not look as tidy as it was before.