Rust 为什么通过提取方法进行重构会触发borrow 判断器错误

我的网络应用程序的体系 struct 可以简化为以下几点:

use std::collections::HashMap;

/// Represents remote user. Usually has fields,
/// but we omit them for the sake of example.
struct User;

impl User {
    /// Send data to remote user.
    fn send(&mut self, data: &str) {
        println!("Sending data to user: \"{}\"", data);
    }
}

/// A service that handles user data.
/// Usually has non-trivial internal state, but we omit it here.
struct UserHandler {
    users: HashMap<i32, User>,  // Maps user id to User objects.
    counter: i32  // Represents internal state
}

impl UserHandler {
    fn handle_data(&mut self, user_id: i32, data: &str) {
        if let Some(user) = self.users.get_mut(&user_id) {
            user.send("Message received!");
            self.counter += 1;
        }
    }
}

fn main() {
    // Initialize UserHandler:
    let mut users = HashMap::new();
    users.insert(1, User{});
    let mut handler = UserHandler{users, counter: 0};

    // Pretend we got message from network:
    let user_id = 1;
    let user_message = "Hello, world!";
    handler.handle_data(user_id, &user_message);
}

Playground

这很好用.我想在UserHandler中创建一个单独的方法，在我们已经确定具有给定id的用户存在时处理用户输入.所以它变成了:

impl UserHandler {
    fn handle_data(&mut self, user_id: i32, data: &str) {
        if let Some(user) = self.users.get_mut(&user_id) {
            self.handle_user_data(user, data);
        }
    }

    fn handle_user_data(&mut self, user: &mut User, data: &str) {
        user.send("Message received!");
        self.counter += 1;
    }
}

Playground

突然，它无法编译！

error[E0499]: cannot borrow `*self` as mutable more than once at a time
  --> src/main.rs:24:13
   |
23 |         if let Some(user) = self.users.get_mut(&user_id) {
   |                             ---------- first mutable borrow occurs here
24 |             self.handle_user_data(user, data);
   |             ^^^^                  ---- first borrow later used here
   |             |
   |             second mutable borrow occurs here

乍一看，错误是非常明显的:你不能有一个对self的可变引用和一个对self的属性的可变引用——这就像有两个对self的可变引用一样.但是，见鬼，我在原始代码中有两个这样的可变引用！

1. 为什么这个简单的重构会触发错误？
2. 我该如何处理它并像这样分解UserHandler::handle_data个方法？

如果您想知道为什么我想要这样的重构，那么考虑一个情况，当用户可以发送的消息类型有多种时，都需要不同的处理，但是有一个共同的部分:必须知道哪User个对象发送了这个消息.