while_let_loop suggestion does not compile

[mahkoh]

use std::cell::RefCell;
use std::rc::Rc;

#[derive(Clone)]
struct X {
    x: Rc<RefCell<Option<X>>>,
}

fn main() {
    let mut x = X {
        x: Rc::new(RefCell::new(None)),
    };
    loop {
        let tmp = match *x.x.borrow() {
            Some(ref y) => y.clone(),
            _ => break,
        };
        x = tmp;
    }  // try: `while let Some(ref y) = *x.x.borrow() { .. }
}

But

error[E0506]: cannot assign to `x` because it is borrowed
  --> src/main.rs:22:9
   |
20 |     while let Some(ref y) = *x.x.borrow() {
   |                              ------------
   |                              |          |
   |                              |          ... and the borrow might be used here, when that temporary is dropped and runs the destructor for type `std::cell::Ref<'_, std::option::Option<X>>`
   |                              borrow of `x` occurs here
   |                              a temporary with access to the borrow is created here ...
21 |         let tmp = y.clone();
22 |         x = tmp;
   |         ^ assignment to borrowed `x` occurs here

[camsteffen]

I've been trying to understand this for fun and I came up with a (kinda) more minimal example.

struct X;

impl X {
    fn y(&self) -> Y<'_> {
        Y(self)
    }
}

struct Y<'a>(&'a X);

impl Drop for Y<'_> {
    fn drop(&mut self) {}
}

impl<'a> Y<'a> {
    fn z(&self) -> Option<X> {
        None
    }
}

fn main() {
    let mut x = X;
    loop {
        let tmp = match x.y().z() {
            Some(xx) => xx,
            _ => break,
        };
        x = tmp;
    }
}