cannot borrow `self.x` as immutable because `*self` is also borrowed as mutable

by

In Rust, the compiler stops at the function call boundary when evaluating generic parameters, which includes generic lifetime parameters. In your case 1, you are calling a method:

fn get_qux(&mut self) -> &mut Qux {
    &mut self.qux
}

This function indicates that all of self will be borrowed mutably, and that the returned reference will live as long as self will. During this time, no other borrows (mutable or not) of self or it’s components may be made.

In your second case, you make up a completely new Qux that has no attachment to your struct whatsoever. It’s not a really great example, because it has very different meaning. If this case works for you, you should do that. However, you won’t be modifying the same thing as case 1.

In the third case, you avoid the function call. That means that the compiler has a bit more information about what exactly is borrowed. Specifically, it can see that self.qux doesn’t interact at all with self.bars, so there is no error.

You can make your original example work by adding a new scope:

fn run(&mut self) {
    {
        let mut qux = self.get_qux();
        let qux_mut = &mut qux;
        qux_mut.baz = true;
    }

    for bar in &self.bars {
        println!("{:?}", bar);
    }
}

Here, the artificial scope clearly defines where the mutable borrow ends. Once the borrow is over, other items are allowed to make new borrows.

If you need to modify qux inside the loop, then you are required to follow the third pattern:

let mut qux = &mut self.qux;

for bar in &self.bars {
    qux.baz = ! qux.baz;
    println!("{:?}", bar);
}

Or the simpler:

for bar in &self.bars {
    self.qux.baz = ! self.qux.baz;
    println!("{:?}", bar);
}

Many times, you can refactor your code to create new structs that have information and encapsulate a nice mutation boundary to make code like this.

More Related Contents:

  1. How do I return a reference to something inside a RefCell without breaking encapsulation?
  2. Mutably borrow one struct field while borrowing another in a closure
  3. Why is it possible to implement Read on an immutable reference to File?
  4. In Rust, what’s the difference between “shadowing” and “mutability”?
  5. How to use struct self in member method closure
  6. How can I modify self in a closure called from a member function?
  7. What is the difference between immutable and const variables in Rust?
  8. How does the Rust compiler know `Cell` has internal mutability?
  9. Why does refactoring by extracting a method trigger a borrow checker error?
  10. What is this question mark operator about?
  11. How do I borrow a reference to what is inside an Option?
  12. What is lifetime elision in very simple terms?
  13. How to create a String directly?
  14. What’s the Rust idiom to define a field pointing to a C opaque pointer?
  15. What is the right way to allocate data to pass to an FFI call?
  16. Read large files line by line in Rust [duplicate]
  17. Why is it discouraged to accept a reference &String, &Vec, or &Box as a function argument?
  18. How to represent shared mutable state?
  19. How can I pull data out of an Option for independent use?
  20. Mutable self while reading from owner object
  21. How to idiomatically alias a crate in Rust 2018?
  22. Cannot borrow immutable borrowed content as mutable
  23. Why do I get “does not live long enough” in a return value?
  24. Why does the compiler not complain that an iterator moved to a for loop is immutable?
  25. Removing items from a BTreeMap or BTreeSet found through iteration
  26. Why doesn’t the lifetime of a mutable borrow end when the function call is complete?
  27. How to tell what “features” are available per crate?
  28. How to initialize the logger for integration tests?
  29. How do I avoid unwrap when converting a vector of Options or Results to only the successful values?
  30. Do I have to implement a trait twice when implementing it for both reference and non-reference types?

Leave a Comment