我是相当新的生 rust ，我有一个问题，借检查。
我有这样一个函数：

impl<'a> DFA<'a> {
    fn solve_next(&mut self, c: Option<char>) -> Option<TokenType> {
        let node = self.state.unwrap_or_else(|| &self.start_node);
        let checks: Vec<char> = node.connections.iter().map(|x| x.1).collect();
        let mut position = None;
        if let Some(c) = c {
            position = checks.iter().position(|x| *x == c);
        }
        if let Some(i) = position {
            let node = &node.connections[i].0;
            self.state = Some(node);
            None
        } else {
            if node.is_end {
                return Some(TokenType::Keyword);
            }
            panic!("Invalid charter for current set");
        }
    }
}

此函数在循环完成时返回TokenType（枚举），在循环未完成时返回None。它位于此结构上：

struct DFA<'a> {
    state: Option<&'a Node>,
    start_node: Node,
}

节点为：

struct Node {
    connections: Vec<(Node, char)>,
    is_end: bool,
    token_type: TokenType,
}

本发明的方法

fn insert(&mut self, _match: char, end: bool) -> &mut Node {

它创建并返回一个新节点，并将该节点添加到它自己连接中。
因此，当我想循环使用solve next函数时，我尝试：

impl<'a> Lexer<'a> {
    fn next_char(&self) -> Option<char> {
        let mut r: Option<char> = None;
        for c in &self.chars {
            match c {
                ' ' | '\n' | '\r' => {
                    continue;
                }
                _ => {
                    r = Some(c.clone());
                    break;
                }
            }
        }
        return r;
    }
    fn next_token(&'a mut self) {
        let somechar = 'c';
        let mut x = self.dfa.solve_next(self.next_char());
        while let None = x {
            x = self.dfa.solve_next(self.next_char());
        }
    }
}

该方法

struct Lexer<'a> {
    //the output of the lexer
    pub tokens: Vec<Token>,

    chars: Vec<char>,

    dfa: DFA<'a>,
}

编译错误是

error[E0499]: cannot borrow `self.dfa` as mutable more than once at a time
   --> src/main.rs:177:17
    |
146 | impl<'a> Lexer<'a> {
    |      -- lifetime `'a` defined here
...
175 |         let mut x = self.dfa.solve_next(self.next_char());
    |                     -------------------------------------
    |                     |
    |                     first mutable borrow occurs here
    |                     argument requires that `self.dfa` is borrowed for `'a`
176 |         while let None = x {
177 |             x = self.dfa.solve_next(self.next_char());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ second mutable borrow occurs here

error[E0502]: cannot borrow `*self` as immutable because it is also borrowed as mutable
   --> src/main.rs:177:37
    |
146 | impl<'a> Lexer<'a> {
    |      -- lifetime `'a` defined here
...
175 |         let mut x = self.dfa.solve_next(self.next_char());
    |                     -------------------------------------
    |                     |
    |                     mutable borrow occurs here
    |                     argument requires that `self.dfa` is borrowed for `'a`
176 |         while let None = x {
177 |             x = self.dfa.solve_next(self.next_char());
    |                                     ^^^^^^^^^^^^^^^^ immutable borrow occurs here

那么，我可以在这个循环中使用solve_next吗？因为我不知道如何创建一个函数，它可以像这样使用，而不需要一个可变的引用。