用?运算符替换unwrap()引发Rust借用检查器错误

问题还原 #

在优化计算器解析器的错误处理时，将unwrap()替换为?运算符后，编译器抛出如下错误：

cannot borrow *self as immutable because it is also borrowed as mutable

修改后的关键代码片段：

fn primary(&mut self) -> Result<Expression, &str> {
    let token = self.current_token()?;
    self.consume_token();
    match token {
        Token::Integer(n) => Ok(Expression::Integer(n)),
        Token::OpenParent => {
            let expr = self.expression()?;
            // 此处触发借用冲突错误
            match self.current_token().unwrap() {
                Token::CloseParent => Ok(expr),
                _ => Err("syntaxerr"),
            }
        }
        ...
    }
}

原因解析 #

问题核心在于?运算符的生命周期绑定特性：

• 你的primary方法返回Result<Expression, &str>，Rust的生命周期推导会将返回的&str错误信息与输入参数&mut self的生命周期绑定。
• 调用self.expression()?时，expression是接收&mut self的方法，会生成一个self的可变借用。由于?运算符会将这个可变借用的生命周期延长至函数返回，后续调用self.current_token()（需要不可变借用）时，就触发了“可变与不可变借用冲突”的规则。
• 而之前用unwrap()时，它会直接取出Result的Ok值或触发panic，不会保留借用的生命周期，因此借用检查器认为可变借用已经结束，允许后续的不可变操作。

解决方案 #

方案1：改用String作为错误类型（推荐） #

将所有返回Result<..., &str>的方法改为返回Result<..., String>，让错误信息脱离self的生命周期约束：

修改current_token方法：

fn current_token(&self) -> Result<Token, String> {
    if self.current_index >= self.tokens.len() {
        return Err("Current index out of range".to_string());
    }
    Ok(self.tokens[self.current_index])
}

修改primary方法的返回类型与逻辑：

fn primary(&mut self) -> Result<Expression, String> {
    let token = self.current_token()?;
    self.consume_token();
    match token {
        Token::Integer(n) => Ok(Expression::Integer(n)),
        Token::OpenParent => {
            let expr = self.expression()?;
            match self.current_token()? {
                Token::CloseParent => {
                    self.consume_token(); // 补充：消耗右括号Token，避免解析残留
                    Ok(expr)
                }
                _ => Err("Syntax error: expected closing parenthesis".to_string()),
            }
        }
        Token::Minus => {
            let expr = self.factor()?;
            Ok(Expression::Unary(Operator::Neg, Box::new(expr)))
        }
        _ => Err("Syntax error: unexpected token".to_string()),
    }
}

方案2：手动控制借用生命周期（不推荐） #

如果坚持使用&str作为错误类型，可以手动处理Result的错误分支，避免?延长可变借用的生命周期：

fn primary(&mut self) -> Result<Expression, &str> {
    let token = self.current_token()?;
    self.consume_token();
    match token {
        Token::OpenParent => {
            // 手动处理expression的错误，避免?绑定生命周期
            let expr = match self.expression() {
                Ok(e) => e,
                Err(msg) => return Err(msg),
            };
            // 此时可变借用已结束，可正常调用current_token
            match self.current_token()? {
                Token::CloseParent => {
                    self.consume_token();
                    Ok(expr)
                }
                _ => Err("syntaxerr"),
            }
        }
        // 其他分支逻辑不变
        ...
    }
}

额外修复提示 #

原代码处理OpenParent分支时，没有消耗右括号的Token，会导致后续解析出现残留错误，修改时记得补充self.consume_token()。

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