refactor(tazjin/rlox): Unify parser::Statement & parser::Declaration

Change-Id: I6f21b246eb9d3bf760edb3220ce6be5de5b05b08
Reviewed-on: https://cl.tvl.fyi/c/depot/+/2302
Reviewed-by: tazjin <mail@tazj.in>
Tested-by: BuildkiteCI
This commit is contained in:
Vincent Ambo 2020-12-31 17:59:19 +03:00 committed by tazjin
parent 26ed836e1d
commit 3c979acdf3
2 changed files with 20 additions and 27 deletions

View file

@ -1,5 +1,5 @@
use crate::errors::{Error, ErrorKind};
use crate::parser::{self, Declaration, Expr, Literal, Program, Statement};
use crate::parser::{self, Expr, Literal, Program, Statement};
use crate::scanner::{self, TokenKind};
use std::collections::HashMap;
use std::rc::Rc;
@ -78,6 +78,14 @@ pub struct Interpreter {
}
impl Interpreter {
pub fn interpret<'a>(&mut self, program: &Program<'a>) -> Result<(), Error> {
for stmt in program {
self.interpret_stmt(stmt)?;
}
Ok(())
}
fn interpret_stmt<'a>(&mut self, stmt: &Statement<'a>) -> Result<(), Error> {
match stmt {
Statement::Expr(expr) => {
@ -87,6 +95,7 @@ impl Interpreter {
let result = self.eval(expr)?;
println!("{:?}", result)
}
Statement::Var(var) => return self.interpret_var(var),
}
Ok(())
@ -102,17 +111,6 @@ impl Interpreter {
return Ok(());
}
pub fn interpret<'a>(&mut self, program: &Program<'a>) -> Result<(), Error> {
for decl in program {
match decl {
Declaration::Stmt(stmt) => self.interpret_stmt(stmt)?,
Declaration::Var(var) => self.interpret_var(var)?,
}
}
Ok(())
}
fn eval<'a>(&mut self, expr: &Expr<'a>) -> Result<Literal, Error> {
match expr {
Expr::Assign(assign) => self.eval_assign(assign),

View file

@ -54,13 +54,8 @@ pub enum Expr<'a> {
Variable(Variable<'a>),
}
#[derive(Debug)]
pub enum Statement<'a> {
Expr(Expr<'a>),
Print(Expr<'a>),
}
// Not to be confused with `Variable`, which is for access.
// Variable assignment. Not to be confused with `Variable`, which is
// for access.
#[derive(Debug)]
pub struct Var<'a> {
pub name: Token<'a>,
@ -68,12 +63,13 @@ pub struct Var<'a> {
}
#[derive(Debug)]
pub enum Declaration<'a> {
Stmt(Statement<'a>),
pub enum Statement<'a> {
Expr(Expr<'a>),
Print(Expr<'a>),
Var(Var<'a>),
}
pub type Program<'a> = Vec<Declaration<'a>>;
pub type Program<'a> = Vec<Statement<'a>>;
// Parser
@ -109,20 +105,19 @@ struct Parser<'a> {
type ExprResult<'a> = Result<Expr<'a>, Error>;
type StmtResult<'a> = Result<Statement<'a>, Error>;
type DeclResult<'a> = Result<Declaration<'a>, Error>;
impl<'a> Parser<'a> {
// recursive-descent parser functions
fn declaration(&mut self) -> DeclResult<'a> {
fn declaration(&mut self) -> StmtResult<'a> {
if self.match_token(&[TokenKind::Var]) {
return self.var_declaration();
}
Ok(Declaration::Stmt(self.statement()?))
self.statement()
}
fn var_declaration(&mut self) -> DeclResult<'a> {
fn var_declaration(&mut self) -> StmtResult<'a> {
// Since `TokenKind::Identifier` carries data, we can't use
// `consume`.
if let TokenKind::Identifier(_) = self.peek().kind {
@ -136,7 +131,7 @@ impl<'a> Parser<'a> {
}
self.consume(&TokenKind::Semicolon, ErrorKind::ExpectedSemicolon)?;
return Ok(Declaration::Var(var));
return Ok(Statement::Var(var));
}
return Err(Error {