Can't call &mut method inside expression used as argument for a &mut method of the same struct

[JakubKoralewski]

I tried this code:

fn main() {
    struct Xd;
    impl Xd {
        fn x(&mut self, y: &str) {println!("{}", y)}
    }
    let mut xd = Xd;
    xd.x(match "x" {
        "x" => {
            xd.x("x");
            "x"
        },
        _ => "y"
    })
}

I expected to see this happen: print x twice

Instead, this happened:

   Compiling playground v0.0.1 (/playground)
error[E0499]: cannot borrow `xd` as mutable more than once at a time
 --> src/main.rs:9:13
  |
7 |     xd.x(match "x" {
  |     -- - first borrow later used by call
  |     |
  |     first mutable borrow occurs here
8 |         "x" => {
9 |             xd.x("x");
  |             ^^ second mutable borrow occurs here

error: aborting due to previous error

For more information about this error, try `rustc --explain E0499`.
error: could not compile `playground`

To learn more, run the command again with --verbose.

Meta

rustc --version --verbose:

1.54.0

[jonas-schievink]

This is working as intended. Method receivers are evaluated before arguments, so the outer function call already borrows xd when the second call is evaluated.

cc #49434

[JakubKoralewski]

Thanks. Why is this the intended behavior though?

[jonas-schievink]

Because the receiver is intentionally evaluated before arguments

[JakubKoralewski]

Sorry, I didn't mean to irritate. I just don't understand. EDIT: So lifetime-wise it's kind of as if struct methods accept closures as arguments and are evaluated in the body of the method? My expectation would be to evaluate arguments and pass into the method. I don't understand why the choice is to evaluate receiver first.