I am trying to create math expression evaluator, I am facing this barrow checker problem
Code
struct Parser {
pub source: String,
lexer: Lexer,
n: usize,
tokens: Vec<Token>,
}
impl Parser {
fn addition(&mut self) -> ExprType {
let left = self.multiply();
if self.match_token(&[TokenType::PLUS, TokenType::MINUS]) {
let operator = self.previous();
let right = self.multiply();
return ExprType::Binary(Binary {
left: Box::new(left),
right: Box::new(right),
operator,
});
}
return left
}
fn multiply(&mut self) -> ExprType {
let left = self.term();
if self.match_token(&[TokenType::STAR, TokenType::PLUS]) {
let operator = self.previous();
let right = self.term();
return ExprType::Binary(Binary{
left: Box::new(left),
right: Box::new(right),
operator,
});
}
return left;
}
fn term(&mut self) -> ExprType {
if self.match_token(&[TokenType::NUMBER]) {
let t = self.previous();
match &t.literal {
Some(val) => {
return ExprType::Literal(Literal { value: val });
}
None => panic!("literal value is None but Token is number"),
}
}
panic!("Unexpected token {:?}", self.peek());
}
fn match_token(&mut self, types: &[TokenType]) -> bool {
for t in types.iter() {
if self.check(t) {
self.increment();
return true;
}
}
return false;
}
fn check(&mut self, t: &TokenType) -> bool {
if self.at_end() {
return false;
}
match self.peek() {
Some(t1) => match &t1.tt {
t => true,
_ => false,
},
_ => false,
}
}
fn at_end(&mut self) -> bool {
if let None = self.next_token() {
return true;
}
return false;
}
fn next_token(&mut self) -> Option<&Token> {
if self.n > self.tokens.len() {
return Some(&self.tokens[self.n]);
}
return self.get_token();
}
fn get_token(&mut self) -> Option<&Token> {
let token = self.lexer.next();
match token.tt {
TokenType::EOL => {
return None;
}
_ => self.tokens.push(token),
};
return self.tokens.last();
}
fn previous(&self) -> &Token {
return &self.tokens[self.n - 1];
}
fn peek(&mut self) -> Option<&Token> {
return self.next_token();
}
fn increment(&mut self) {
self.n += 1;
}
}
Error
error[E0499]: cannot borrow `*self` as mutable more than once at a time
--> src/parser/parser.rs:15:12
|
13 | fn addition(&mut self) -> ExprType {
| - let's call the lifetime of this reference `'1`
14 | let left = self.multiply();
| ---- first mutable borrow occurs here
15 | if self.match_token(&[TokenType::PLUS, TokenType::MINUS]) {
| ^^^^ second mutable borrow occurs here
...
24 | return left
| ---- returning this value requires that `*self` is borrowed for `'1`
error[E0502]: cannot borrow `*self` as immutable because it is also borrowed as mutable
--> src/parser/parser.rs:16:28
|
13 | fn addition(&mut self) -> ExprType {
| - let's call the lifetime of this reference `'1`
14 | let left = self.multiply();
| ---- mutable borrow occurs here
15 | if self.match_token(&[TokenType::PLUS, TokenType::MINUS]) {
16 | let operator = self.previous();
| ^^^^ immutable borrow occurs here
...
24 | return left
| ---- returning this value requires that `*self` is borrowed for `'1`
error[E0499]: cannot borrow `*self` as mutable more than once at a time
--> src/parser/parser.rs:17:25
|
13 | fn addition(&mut self) -> ExprType {
| - let's call the lifetime of this reference `'1`
14 | let left = self.multiply();
| ---- first mutable borrow occurs here
...
17 | let right = self.multiply();
| ^^^^ second mutable borrow occurs here
...
24 | return left
| ---- returning this value requires that `*self` is borrowed for `'1`
error[E0499]: cannot borrow `*self` as mutable more than once at a time
--> src/parser/parser.rs:28:12
|
26 | fn multiply(&mut self) -> ExprType {
| - let's call the lifetime of this reference `'1`
27 | let left = self.term();
| ---- first mutable borrow occurs here
28 | if self.match_token(&[TokenType::STAR, TokenType::PLUS]) {
| ^^^^ second mutable borrow occurs here
...
37 | return left;
| ---- returning this value requires that `*self` is borrowed for `'1`
error[E0502]: cannot borrow `*self` as immutable because it is also borrowed as mutable
--> src/parser/parser.rs:29:28
|
26 | fn multiply(&mut self) -> ExprType {
| - let's call the lifetime of this reference `'1`
27 | let left = self.term();
| ---- mutable borrow occurs here
28 | if self.match_token(&[TokenType::STAR, TokenType::PLUS]) {
29 | let operator = self.previous();
| ^^^^ immutable borrow occurs here
...
37 | return left;
| ---- returning this value requires that `*self` is borrowed for `'1`
error[E0499]: cannot borrow `*self` as mutable more than once at a time
--> src/parser/parser.rs:30:25
|
26 | fn multiply(&mut self) -> ExprType {
| - let's call the lifetime of this reference `'1`
27 | let left = self.term();
| ---- first mutable borrow occurs here
...
30 | let right = self.term();
| ^^^^ second mutable borrow occurs here
...
37 | return left;
| ---- returning this value requires that `*self` is borrowed for `'1`
pub trait Expr {
fn accept<V>(self, visitor: impl Visitor<V>) -> V;
}
pub struct Binary<'a> {
left: Box<ExprType<'a>>,
right: Box<ExprType<'a>>,
operator: &'a Token,
}
pub enum ExprType<'a> {
Binary(Binary<'a>),
Literal(Literal<'a>),
}
impl<'a> Expr for Binary<'a> {
fn accept<V>(self, mut visitor: impl Visitor<V>) -> V {
return visitor.visit_binary_operation(self);
}
}
pub struct Literal<'a> {
value: &'a Value,
}
impl<'a> Expr for Literal<'a> {
fn accept<V>(self, mut visitor: impl Visitor<V>) -> V {
return visitor.visit_literal(self);
}
}
trait Visitor<T> {
fn visit_binary_operation(&mut self, expr: impl Expr) -> T;
fn visit_literal(&mut self, expr: impl Expr) -> T;
}
