Causes compilation failure when unmutable borrowing before mutable borrowing

1

sample code:

pub struct MyStruct {}

impl MyStruct {
    pub fn test1(&self) -> &str { "hello" }
    pub fn test2(&mut self) -> &str { "world" }
}

fn main() {
    let mut s = MyStruct{};
    println!("{} {}", s.test1(), s.test2());
}

I think when mutable borrowing and immutable borrowing are on the same line, the compiler should relax the restrictions here to allow compilation to pass, rather than forcing users to modify the code logic

2

The references test1 and test2 both return keep their input borrow alive. And println!() needs all interpolated values to be alive at the same time (it wraps both in a single struct before passing it to a function that performs the actual formatting), thus forcing both borrows of s to be kept alive at the same time.

2 Likes
3

For completeness, here's an example of methods with the same signatures given in the above example where calling any of them invalidates the reference returned by the other, showing that it's correct for your print statement to not compile:

pub struct MyStruct {
    s1: String,
    s2: RefCell<String>,
}

impl MyStruct {
    pub fn test1(&self) -> &str {
        self.s2.borrow_mut() = String::new();
        &self.s1
    }
    pub fn test2(&mut self) -> &str {
        self.s1 = String::new();
        self.s2.get_mut()
    }
}
3 Likes
4

Thank you, I realize my problem