Error while trying to borrow 2 fields from a struct wrapped in RefCell

by

You can manually invoke DerefMut and then save the resulting reference:

fn write(s: RefCell<S>) {
    let mut mut_s = s.borrow_mut();
    let mut tmp = &mut *mut_s; // Here
    let str = &tmp.data.string;
    tmp.writer.write(str.as_bytes());
}

Or in one line:

fn write(s: RefCell<S>) {
    let mut_s = &mut *s.borrow_mut(); // Here
    let str = &mut_s.data.string;
    mut_s.writer.write(str.as_bytes());
}

The problem is that borrow_mut doesn’t return your struct directly — it returns a RefMut. Normally, this is transparent as this struct implements Deref and DerefMut, so any methods called on it are passed to the underlying type. The pseudo-expanded code looks something like this:

use std::cell::RefMut;
use std::ops::{Deref, DerefMut};

fn write(s: RefCell<S>) {
    let mut mut_s: RefMut<S> = s.borrow_mut();
    let str = &Deref::deref(&mut_s).data.string;
    DerefMut::deref_mut(&mut mut_s).writer.write(str.as_bytes());
}

Rust doesn’t track field-level borrows across function calls (even for Deref::deref or DerefMut::deref_mut). This causes your error, as the deref_mut method would need to be called during the outstanding borrow from the previous Deref::deref.

The expanded version with the explicit borrow looks like this, with a single call to Deref::deref_mut:

use std::cell::RefMut;
use std::ops::DerefMut;

fn write(s: RefCell<S>) {
    let mut mut_s: RefMut<S> = s.borrow_mut();
    let tmp: &mut S = DerefMut::deref_mut(&mut mut_s);
    let str = &tmp.data.string;
    tmp.writer.write(str.as_bytes());
}

The compiler can then track that the two borrows from that temporary value are disjoint.

Note that this problem isn’t unique to RefCell! Any type that implements DerefMut can experience the same problem. Here’s some from the standard library:

More Related Contents:

  1. Why do I need to import a trait to use the methods it defines for a type?
  2. Why does linking lifetimes matter only with mutable references?
  3. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  4. Should trait bounds be duplicated in struct and impl?
  5. Can I do type introspection with trait objects and then downcast it?
  6. How can I perform parallel asynchronous HTTP GET requests with reqwest?
  7. Convert a String to int?
  8. How do I borrow a RefCell, find a key, and return a reference to the result? [duplicate]
  9. What is lifetime elision in very simple terms?
  10. error [E0716]: temporary value dropped while borrowed (rust)
  11. Can I get a trait object of a multi-trait instance without using a generic type?
  12. Why does this read input before printing?
  13. How to create a String directly?
  14. What’s the Rust idiom to define a field pointing to a C opaque pointer?
  15. Trait implementation for both a trait object and for direct implementors of the trait
  16. Can’t borrow mutably within two different closures in the same scope
  17. How can I implement Rust’s Copy trait?
  18. How to iterate over and filter an array?
  19. How to use a struct’s member as its own key when inserting the struct into a map without duplicating it?
  20. How to fix lifetime error when function returns a serde Deserialize type?
  21. Is there another option to share an Arc in multiple closures besides cloning it before each closure?
  22. Understanding Traits and Object Safety
  23. How to implement a custom ‘fmt::Debug’ trait?
  24. How do I pass a closure through raw pointers as an argument to a C function?
  25. Is there a way to use existing structs as enum variants?
  26. How do I use a crate from another crate without explicitly defining a new dependency in my project?
  27. How to quiet a warning for a single statement in Rust?
  28. Is there an elegant solution to modifying a structure while iterating?
  29. How do I cope with lazy iterators?
  30. Can a struct containing a raw pointer implement Send and be FFI safe?

Leave a Comment