Cannot borrow `x` as mutable more than once at a time

by

This happens because of how add is defined:

fn add<'a>(node: &'a mut Node, data: &'static str) -> &'a Node

Here it is specified that the lifetime of the resulting reference should be equal to the lifetime of the incoming reference. The only way it is possible (except for unsafe code) is that the resulting reference is somehow derived from the incoming reference, for example, it references some field inside the object the incoming reference points at:

struct X {
    a: u32,
    b: u32,
}

fn borrow_a<'a>(x: &'a mut X) -> &'a mut u32 {
    &mut x.a
}

However, there is no way for the compiler to know what exactly from the incoming structure is borrowed by looking only at the function signature (which, in general, is the only thing it can do when compiling code which uses this function). Therefore, it can’t know that the following code is technically correct:

let mut x = X { a: 1, b: 2 };
let a = borrow_a(&mut x);
let b = &mut x.b;

We know that a and b are disjoint because they point at different parts of the structure, but the compiler can’t know that because there is nothing in borrow_a‘s signature which would suggest it (and there can’t be, Rust does not support it).

Therefore, the only sensible thing the compiler could do is to consider the whole x to be borrowed until the reference returned by borrow_a() is dropped. Otherwise it would be possible to create two mutable references for the same data, which is a violation of Rust aliasing guarantees.

Note that the following code is correct:

let mut x = X { a: 1, b: 2 };
let a = &mut x.a;
let b = &mut x.b;

Here the compiler can see that a and b never point to the same data, even though they do point inside of the same structure.

There is no workaround for this, and the only solution would be to restructure the code so it doesn’t have such borrowing patterns.

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  3. How do I stop iteration and return an error when Iterator::map returns a Result::Err?
  4. Are polymorphic variables allowed?
  5. Why does Iterator::take_while take ownership of the iterator?
  6. When should I implement std::convert::From vs std::convert::Into?
  7. Efficiently mutate a vector while also iterating over the same vector
  8. How can I call a mutating method while holding a reference to self?
  9. How do you actually use dynamically sized types in Rust?
  10. How do I use the Entry API with an expensive key that is only constructed if the Entry is Vacant?
  11. “parameter `’a` is never used” error when ‘a is used in type parameter bound
  12. Borrowing references to attributes in a struct
  13. How do I split a string in Rust?
  14. Is it possible to implement methods on type aliases?
  15. How can I use a module from outside the src folder in a binary project, such as for integration tests or benchmarks?
  16. How can I modify self in a closure called from a member function?
  17. How do I synchronously return a value calculated in an asynchronous Future?
  18. How do I move out of a struct field that is an Option?
  19. How to store rusqlite Connection and Statement objects in the same struct in Rust? [duplicate]
  20. How to model complex recursive data structures (graphs)?
  21. print! macro not executed until pressing Enter
  22. How can I define an async method in a trait?
  23. How do I specify the linker path in Rust?
  24. Why am I getting “parameter is never used [E0392]”?
  25. Why is Rust’s assert_eq! implemented using a match?
  26. Is there a list of all cfg features?
  27. Comparing every element in a vector with the next one
  28. Is there a good way to convert a Vec to an array?
  29. How can I conditionally provide a default reference without performing unnecessary computation when it isn’t used?
  30. How can I build multiple binaries with Cargo?

Leave a Comment