feat(tazjin/rlox): Implement mutable variable assignment

Change-Id: I56db10a5ac26958ae27a8d4c8fa7b8f8285bc7e1
Reviewed-on: https://cl.tvl.fyi/c/depot/+/2299
Reviewed-by: tazjin <mail@tazj.in>
Tested-by: BuildkiteCI
This commit is contained in:
Vincent Ambo 2020-12-31 16:31:34 +03:00 committed by tazjin
parent 8ab66f1689
commit cc958e6730
3 changed files with 74 additions and 33 deletions

View file

@ -9,6 +9,7 @@ pub enum ErrorKind {
TypeError(String),
UndefinedVariable(String),
InternalError(String),
InvalidAssignmentTarget(String),
}
#[derive(Debug)]

View file

@ -1,6 +1,6 @@
use crate::errors::{Error, ErrorKind};
use crate::parser::{self, Declaration, Expr, Literal, Program, Statement};
use crate::scanner::TokenKind;
use crate::scanner::{self, TokenKind};
use std::collections::HashMap;
// Tree-walk interpreter
@ -11,24 +11,31 @@ struct Environment {
}
impl Environment {
fn define(&mut self, name: &str, value: Literal) {
self.values.insert(name.into(), value);
fn define(&mut self, name: &scanner::Token, value: Literal) -> Result<(), Error> {
let ident = identifier_str(name)?;
self.values.insert(ident.into(), value);
Ok(())
}
fn get(&self, name: &parser::Variable) -> Result<Literal, Error> {
if let TokenKind::Identifier(ident) = &name.0.kind {
return self
.values
.get(ident)
.map(Clone::clone)
.ok_or_else(|| Error {
line: name.0.line,
kind: ErrorKind::UndefinedVariable(ident.into()),
});
}
let ident = identifier_str(&name.0)?;
self.values
.get(ident)
.map(Clone::clone)
.ok_or_else(|| Error {
line: name.0.line,
kind: ErrorKind::UndefinedVariable(ident.into()),
})
}
}
fn identifier_str<'a>(name: &'a scanner::Token) -> Result<&'a str, Error> {
if let TokenKind::Identifier(ident) = &name.kind {
Ok(ident)
} else {
Err(Error {
line: name.0.line,
line: name.line,
kind: ErrorKind::InternalError("unexpected identifier kind".into()),
})
}
@ -40,7 +47,7 @@ pub struct Interpreter {
}
impl Interpreter {
fn interpret_stmt<'a>(&self, stmt: &Statement<'a>) -> Result<(), Error> {
fn interpret_stmt<'a>(&mut self, stmt: &Statement<'a>) -> Result<(), Error> {
match stmt {
Statement::Expr(expr) => {
self.eval(expr)?;
@ -55,20 +62,13 @@ impl Interpreter {
}
fn interpret_var<'a>(&mut self, var: &parser::Var<'a>) -> Result<(), Error> {
if let TokenKind::Identifier(ident) = &var.name.kind {
let init = var.initialiser.as_ref().ok_or_else(|| Error {
line: var.name.line,
kind: ErrorKind::InternalError("missing variable initialiser".into()),
})?;
self.globals.define(ident, self.eval(init)?);
return Ok(());
}
Err(Error {
let init = var.initialiser.as_ref().ok_or_else(|| Error {
line: var.name.line,
kind: ErrorKind::InternalError("unexpected identifier kind".into()),
})
kind: ErrorKind::InternalError("missing variable initialiser".into()),
})?;
let value = self.eval(init)?;
self.globals.define(&var.name, value)?;
return Ok(());
}
pub fn interpret<'a>(&mut self, program: &Program<'a>) -> Result<(), Error> {
@ -82,8 +82,9 @@ impl Interpreter {
Ok(())
}
fn eval<'a>(&self, expr: &Expr<'a>) -> Result<Literal, Error> {
fn eval<'a>(&mut self, expr: &Expr<'a>) -> Result<Literal, Error> {
match expr {
Expr::Assign(assign) => self.eval_assign(assign),
Expr::Literal(lit) => Ok(lit.clone()),
Expr::Grouping(grouping) => self.eval(&*grouping.0),
Expr::Unary(unary) => self.eval_unary(unary),
@ -92,7 +93,7 @@ impl Interpreter {
}
}
fn eval_unary<'a>(&self, expr: &parser::Unary<'a>) -> Result<Literal, Error> {
fn eval_unary<'a>(&mut self, expr: &parser::Unary<'a>) -> Result<Literal, Error> {
let right = self.eval(&*expr.right)?;
match (&expr.operator.kind, right) {
@ -109,7 +110,7 @@ impl Interpreter {
}
}
fn eval_binary<'a>(&self, expr: &parser::Binary<'a>) -> Result<Literal, Error> {
fn eval_binary<'a>(&mut self, expr: &parser::Binary<'a>) -> Result<Literal, Error> {
let left = self.eval(&*expr.left)?;
let right = self.eval(&*expr.right)?;
@ -152,6 +153,12 @@ impl Interpreter {
Ok(result)
}
fn eval_assign<'a>(&mut self, assign: &parser::Assign<'a>) -> Result<Literal, Error> {
let value = self.eval(&assign.value)?;
self.globals.define(&assign.name, value.clone())?;
Ok(value)
}
}
// Interpreter functions not dependent on interpreter-state.

View file

@ -10,6 +10,12 @@ use crate::scanner::{Token, TokenKind};
// AST
#[derive(Debug)]
pub struct Assign<'a> {
pub name: Token<'a>,
pub value: Box<Expr<'a>>,
}
#[derive(Debug)]
pub struct Binary<'a> {
pub left: Box<Expr<'a>>,
@ -34,11 +40,13 @@ pub struct Unary<'a> {
pub right: Box<Expr<'a>>,
}
// Not to be confused with `Var`, which is for assignment.
#[derive(Debug)]
pub struct Variable<'a>(pub Token<'a>);
#[derive(Debug)]
pub enum Expr<'a> {
Assign(Assign<'a>),
Binary(Binary<'a>),
Grouping(Grouping<'a>),
Literal(Literal),
@ -81,7 +89,9 @@ statement → exprStmt
exprStmt expression ";" ;
printStmt "print" expression ";" ;
expression equality ;
expression assignment ;
assignment IDENTIFIER "=" assignment
| equality ;
equality comparison ( ( "!=" | "==" ) comparison )* ;
comparison term ( ( ">" | ">=" | "<" | "<=" ) term )* ;
term factor ( ( "-" | "+" ) factor )* ;
@ -156,7 +166,30 @@ impl<'a> Parser<'a> {
}
fn expression(&mut self) -> ExprResult<'a> {
self.equality()
self.assignment()
}
fn assignment(&mut self) -> ExprResult<'a> {
let expr = self.equality()?;
if self.match_token(&[TokenKind::Equal]) {
let equals = self.previous().clone();
let value = self.assignment()?;
if let Expr::Variable(Variable(name)) = expr {
return Ok(Expr::Assign(Assign {
name,
value: Box::new(value),
}));
}
return Err(Error {
line: equals.line,
kind: ErrorKind::InvalidAssignmentTarget(format!("{:?}", equals)),
});
}
Ok(expr)
}
fn equality(&mut self) -> ExprResult<'a> {