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

Change-Id: I6f21b246eb9d3bf760edb3220ce6be5de5b05b08
Reviewed-on: https://cl.tvl.fyi/c/depot/+/2302
Reviewed-by: tazjin <mail@tazj.in>
Tested-by: BuildkiteCI

2 files changed, 20 insertions, 27 deletions

diff --git a/users/tazjin/rlox/src/interpreter.rs b/users/tazjin/rlox/src/interpreter.rs
index c0af7d0476..edaa5e28f2 100644
--- a/users/tazjin/rlox/src/interpreter.rs
+++ b/users/tazjin/rlox/src/interpreter.rs
@@ -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),
diff --git a/users/tazjin/rlox/src/parser.rs b/users/tazjin/rlox/src/parser.rs
index b46e570994..1a271fd0ae 100644
--- a/users/tazjin/rlox/src/parser.rs
+++ b/users/tazjin/rlox/src/parser.rs
@@ -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 {