Rust编译错误E0499：无法多次可变借用*self求解决方案

error[E0499]: cannot borrow `*self` as mutable more than once at a time
   --> src\scanner\mod.rs:103:17
    |
45  | impl<'a> Scanner<'a> {
    |      -- lifetime `'a` defined here
...
102 |                 let message = self.intern_str(&message);
    |                               -------------------------
    |                               |
    |                               first mutable borrow occurs here
    |                               argument requires that `*self` is borrowed for `'a`
103 |                 self.error_token(message);
    |                 ^^^^ second mutable borrow occurs here

pub struct ScannerResult<'a> {
    line_starts: &'a mut Vec<usize>,
    tokens: &'a mut Vec<Token<'a>>,
}

impl<'a> ScannerResult<'a> {
    pub fn new(line_starts: &'a mut Vec<usize>, tokens: &'a mut Vec<Token<'a>>) -> Self {
        Self {
            line_starts,
            tokens,
        }
    }

    pub fn push_token(&mut self, token: Token<'a>) {
        self.tokens.push(token);
    }

    pub fn push_line_start(&mut self, line_start: usize) {
        self.line_starts.push(line_start);
    }
}
struct Scanner<'a> {
    src: Chars<'a>,
    offset: usize,
    start: usize,
    size: usize,
    string_table: &'a mut HashSet<String>,
    keyword_trie: KeywordTrie,
    result: &'a mut ScannerResult<'a>,
    has_more_tokens: bool,
}

impl<'a> Scanner<'a> {
    pub fn new(
        src: &'a str,
        size: usize,
        string_table: &'a mut HashSet<String>,
        result: &'a mut ScannerResult<'a>,
    ) -> Self {
        Self {
            src: src.chars(),
            offset: 0,
            start: 0,
            size,
            string_table,
            keyword_trie: KeywordTrie::new(),
            result,
            has_more_tokens: true,
        }
    }

    fn next(&'a mut self) -> Option<&Token<'a>> {
        self.skipWhitespaces();
        if self.is_eof() {
            return self.tokenize_eof();
        }

        let c = self.advance();

        if c.is_none() {
            return None;
        }

        let c = c.unwrap();

        return match c {
            '{' => self.tokenize(&TokenType::OPEN_CURLY_BRACKET, None),
            '}' => self.tokenize(&TokenType::CLOSE_CURLY_BRACKET, None),
            '(' => self.tokenize(&TokenType::OPEN_PAREN, None),
            ')' => self.tokenize(&TokenType::CLOSE_PAREN, None),
            '[' => self.tokenize(&TokenType::OPEN_SQUARE_BRACKET, None),
            ']' => self.tokenize(&TokenType::CLOSE_SQUARE_BRACKET, None),
            ':' => self.tokenize(&TokenType::COLON, None),
            ';' => self.tokenize(&TokenType::SEMICOLON, None),
            ',' => self.tokenize(&TokenType::COMMA, None),
            '@' => self.tokenize(&TokenType::AT, None),
            _ => {
                let message = format!("Unexpected character: {}", c);
                let message = self.intern_str(&message);
                self.error_token(message);
                return None;
            }
        };
    }

    fn error_token(&mut self, message: &'a str) -> Option<&Token<'a>> {
        return self.tokenize(&TokenType::ERROR, Some(message));
    }

    fn tokenize_eof(&mut self) -> Option<&Token<'a>> {
        self.has_more_tokens = false;
        self.tokenize(&TokenType::EOF, None)
    }

    fn intern_str(&mut self, string: &String) -> &str {
        if !self.string_table.contains(string) {
            self.string_table.insert(string.to_owned());
        }
        self.string_table.get(string).unwrap()
    }

    fn tokenize(
        &mut self,
        token_type: &'static TokenType,
        lexeme: Option<&'a str>,
    ) -> Option<&Token<'a>> {
        let token: Token<'a> = Token::new(token_type, lexeme, self.start, self.offset);
        self.result.push_token(token);
        self.start = self.offset;
        self.result.tokens.last()
    }
}

我大概清楚错误是同时多次可变借用self导致的，但没找到解决思路。试过把代码内联、直接借用string_table而非self，但不用字符串驻留会出现“message生命周期不足”的错误，又没法把message设为'static（因为要显示具体的意外字符）。刚学Rust，和借用检查器死磕中，求帮忙解决。

核心问题是intern_str返回的引用绑定到了Scanner的'a生命周期，导致第一次调用intern_str时对self的可变借用会持续到'a结束，后续调用error_token再次可变借用self就触发了冲突。下面是几种可行的解决方式：

1. 拆分字段，避免借用整个self #

把字符串驻留逻辑从self中拆分出来，单独传递string_table引用，这样调用intern_str时只借用string_table，而非整个self：

// 把intern_str改成独立函数，接收string_table的可变引用
fn intern_str(string_table: &'a mut HashSet<String>, string: &String) -> &'a str {
    if !string_table.contains(string) {
        string_table.insert(string.to_owned());
    }
    string_table.get(string).unwrap()
}

然后在next方法的分支中调用：

_ => {
    let message = format!("Unexpected character: {}", c);
    // 只借用string_table，而非整个self
    let message = intern_str(&mut self.string_table, &message);
    self.error_token(message);
    return None;
}

这种方式让两次借用的对象不重叠，彻底避免冲突。

2. 内联驻留逻辑，缩短借用时间 #

把intern_str的逻辑直接内联到next的分支里，让对string_table的可变借用在调用error_token前就释放：

_ => {
    let message = format!("Unexpected character: {}", c);
    // 先完成字符串驻留，操作完成后释放对string_table的借用
    self.string_table.insert(message.clone());
    let message_ref = self.string_table.get(&message).unwrap();
    // 此时已无活跃的string_table借用，可正常调用error_token
    self.error_token(message_ref);
    return None;
}

这种方式虽然会多一次字符串克隆，但错误信息的克隆开销可以忽略，代码改动也很小。

3. 使用内部可变性（适合复杂场景） #

如果需要更灵活的借用，可以用RefCell包裹string_table，允许在不可变借用self的情况下修改内部数据：

// 修改Scanner的string_table字段
struct Scanner<'a> {
    // ...其他字段不变
    string_table: &'a RefCell<HashSet<String>>,
    // ...其他字段不变
}

// 修改intern_str方法
fn intern_str(&self, string: &String) -> &str {
    let mut table = self.string_table.borrow_mut();
    if !table.contains(string) {
        table.insert(string.to_owned());
    }
    table.get(string).unwrap()
}

注意这种方式需要配合RefCell的借用规则，且返回的引用生命周期受限于RefCell的借用，若要返回'a生命周期的引用，可能需要用Rc<String>存储字符串，复杂度较高，适合有特殊需求的场景。

推荐方案 #

优先选择第一种拆分字段的方式，它最符合Rust的借用规则，代码逻辑清晰，没有额外性能开销。

内容的提问来源于stack exchange，提问作者Omega500