Cannot borrow as immutable because it is also borrowed as mutable in function arguments

by

This line:

n.set(n.get() + 1);

is desugared into

Number::set(&mut n, n.get() + 1);

The error message might be a bit more clear now:

error[E0502]: cannot borrow `n` as immutable because it is also borrowed as mutable
  --> <anon>:18:25
   |
18 |     Number::set(&mut n, n.get() + 1);
   |                      -  ^          - mutable borrow ends here
   |                      |  |
   |                      |  immutable borrow occurs here
   |                      mutable borrow occurs here

As Rust evaluates arguments left to right, that code is equivalent to this:

let arg1 = &mut n;
let arg2 = n.get() + 1;
Number::set(arg1, arg2);

Editor’s note: This code example gives an intuitive sense of the underlying problem, but isn’t completely accurate. The expanded code still fails even with non-lexical lifetimes, but the original code compiles. For the full description of the problem, review the comments in the original implementation of the borrow checker

It should now be obvious what is wrong. Swapping those first two lines fixes this, but Rust does not do that kind of control-flow analysis.

This was first created as bug #6268, now it is integrated into RFC 2094, non-lexical-lifetimes. If you use Rust 1.36 or newer, NLL is enabled automatically and your code will now compile without an error.

See also:

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. Cannot move out of value which is behind a shared reference when unwrapping
  3. Why does refactoring by extracting a method trigger a borrow checker error?
  4. Temporarily move out of borrowed content
  5. Returning a reference from a HashMap or Vec causes a borrow to last beyond the scope it’s in?
  6. Passing mutable self reference to method of owned object
  7. Mutably borrow one struct field while borrowing another in a closure
  8. Do mutable references have move semantics?
  9. Double mutable borrow error in a loop happens even with NLL on
  10. What are the options to end a mutable borrow in Rust?
  11. How to update-or-insert on a Vec?
  12. “borrowed value does not live long enough” when using the builder pattern
  13. How to use struct self in member method closure
  14. Can’t borrow mutably within two different closures in the same scope
  15. Temporary value is freed at the end of this statement [duplicate]
  16. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  17. How can I modify self in a closure called from a member function?
  18. How do I move out of a struct field that is an Option?
  19. Why does this mutable borrow live beyond its scope?
  20. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  21. How to return a reference to a sub-value of a value that is under a mutex?
  22. How can this instance seemingly outlive its own parameter lifetime?
  23. Why does removing return give me an error: expected type `()` but found type
  24. Linking the lifetimes of self and a reference in method
  25. Is there a way to create a function pointer to a method in Rust?
  26. Borrow two mutable values from the same HashMap
  27. Is there any difference between matching on a reference to a pattern or a dereferenced value?
  28. How do I print an integer in binary with leading zeros?
  29. How does Rust’s type inference work across multiple statements?
  30. How to pass rustc flags to cargo?

Leave a Comment