Rust编译错误E0502：无法可变借用self，因已被不可变借用

错误原因 #

你遇到的E0502错误，本质是违反了Rust的借用核心规则：同一时间不能对同一数据同时存在可变引用和不可变引用。具体到你的代码：

• let mut iter = self.file.chars(); 这一行中，chars()返回的Chars迭代器持有self.file的不可变引用，只要iter还存活，这个不可变借用就一直有效。
• 调用self.get_lexeme(&mut iter)时，get_lexeme需要&mut self（对self的可变借用），而你的子方法（比如get_string）还会调用file.split_off直接修改self.file——相当于同时存在self.file的不可变借用（来自iter）和可变借用（来自&mut self），借用检查器直接触发报错。

修复方案 #

核心思路是消除同时存在的冲突借用，最直接的方式是抛弃Chars迭代器，改用索引跟踪遍历位置，这样不需要持有self.file的引用，只通过可变借用&mut self修改索引即可。

修改后的代码示例 #

pub enum LexemeKind {
    Number,
    Operator,
    String,
    // 根据你的需求补充其他词法单元类型
}

pub struct Lexeme {
    pub content: String,
    pub kind: LexemeKind,
}

pub struct Lexer {
    pub file: String,
    pub lexemes: Vec<Lexeme>,
    pos: usize, // 跟踪当前遍历的字符串索引位置
}

impl Lexer {
    pub fn new(file_path: &String) -> Self {
        // 读取文件内容，初始化遍历位置为0
        let file = std::fs::read_to_string(file_path).expect("Failed to read file");
        Lexer {
            file,
            lexemes: Vec::new(),
            pos: 0,
        }
    }

    pub fn process(&mut self) {
        while let Some(lexeme) = self.get_lexeme() {
            self.lexemes.push(lexeme);
        }
    }

    fn get_lexeme(&mut self) -> Option<Lexeme> {
        // 跳过空白字符（可选，根据你的词法规则调整）
        while self.pos < self.file.len() && self.file.chars().nth(self.pos).unwrap().is_whitespace() {
            self.pos += 1;
        }

        // 遍历到字符串末尾，返回None结束
        if self.pos >= self.file.len() {
            return None;
        }

        let current_char = self.file.chars().nth(self.pos).unwrap();
        let kind = get_kind(current_char);

        // 根据词法类型获取完整内容
        let content = match kind {
            LexemeKind::Number => self.get_number(),
            LexemeKind::Operator => self.get_operator(),
            LexemeKind::String => self.get_string(),
            // 补充其他类型的处理逻辑
        };

        Some(Lexeme { content, kind })
    }

    // 读取数字词法单元
    fn get_number(&mut self) -> String {
        let start = self.pos;
        // 持续读取数字字符
        while self.pos < self.file.len() && self.file.chars().nth(self.pos).unwrap().is_ascii_digit() {
            self.pos += 1;
        }
        // 截取对应区间的字符串
        self.file[start..self.pos].to_string()
    }

    // 读取操作符词法单元
    fn get_operator(&mut self) -> String {
        let op = self.file.chars().nth(self.pos).unwrap().to_string();
        self.pos += 1;
        op
    }

    // 读取字符串词法单元（假设用双引号包裹）
    fn get_string(&mut self) -> String {
        self.pos += 1; // 跳过开头的双引号
        let start = self.pos;
        // 读取到结尾双引号为止
        while self.pos < self.file.len() && self.file.chars().nth(self.pos).unwrap() != '"' {
            self.pos += 1;
        }
        let content = self.file[start..self.pos].to_string();
        self.pos += 1; // 跳过结尾的双引号
        content
    }
}

// 判断当前字符对应的词法类型
fn get_kind(c: char) -> LexemeKind {
    if c.is_ascii_digit() {
        LexemeKind::Number
    } else if matches!(c, '+' | '-' | '*' | '/') {
        LexemeKind::Operator
    } else if c == '"' {
        LexemeKind::String
    } else {
        // 这里根据你的词法规则补充其他类型，比如标识符、括号等
        LexemeKind::Operator
    }
}

方案优势 #

• 彻底避免了借用冲突：所有操作通过pos索引完成，只需要&mut self这一个可变借用，没有额外的引用持有。
• 逻辑更直观：索引遍历的方式更容易跟踪当前位置，调试也更方便。
• 保留了原有的功能：依然可以完成词法分析的核心逻辑，只是换了一种遍历字符串的方式。

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