Refactor statement module tree

src/ast/parser.rs

@@ -1,5 +1,5 @@
 use super::ast_parser_iter::ParserIter;
-use super::statement::statement_node;
+use super::statement;
 use crate::error::ErrorLocationWrapper;
 use crate::lexer::{token, token::TokenType};
 use std::result::Result as StdResult;
@@ -29,7 +29,7 @@ pub struct Parser<'a, T: Iterator<Item = token::Token<'a>>> {
 	pub(super) token_iter: super::ast_parser_iter::ParserIter<T>,
 }
 
-pub type ParseAllResult = StdResult<Vec<statement_node::Statement>, Vec<ASTParsingError>>;
+pub type ParseAllResult = StdResult<Vec<statement::Statement>, Vec<ASTParsingError>>;
 
 impl<'a, T: Iterator<Item = token::Token<'a>>> Parser<'a, T> {
 	pub fn new(iter: T) -> Parser<'a, T> {

src/ast/statement/expression_statement.rs

@@ -0,0 +1,28 @@
+use crate::{
+	ast::expression::expression_node::ExpressionNode,
+	ast::parser::{InnerASTParsingError, Parser, Result},
+	lexer::token::{self, TokenType},
+};
+
+use super::Statement;
+
+#[derive(Debug)]
+pub struct ExpressionStatement(pub ExpressionNode);
+impl ExpressionStatement {
+	pub fn new(expr: ExpressionNode) -> Self {
+		Self(expr)
+	}
+}
+
+impl<'a, T: Iterator<Item = token::Token<'a>>> Parser<'a, T> {
+	pub fn expression_statement(&mut self) -> Result<Statement> {
+		let expr = self.expression()?;
+		let token = self.token_iter.peek();
+		if let TokenType::Semicolon = token.token_type {
+			self.token_iter.next();
+			Ok(ExpressionStatement::new(expr).into())
+		} else {
+			Err(token.location.wrap(InnerASTParsingError::ExpectedSemi))
+		}
+	}
+}

src/ast/statement/mod.rs

@@ -1,2 +1,37 @@
-pub mod statement_node;
-mod statement_parser;
+use crate::lexer::token;
+
+use super::parser::{InnerASTParsingError, Parser, Result};
+
+mod expression_statement;
+mod print_statement;
+mod variable_assignment_statement;
+
+pub use expression_statement::ExpressionStatement;
+pub use print_statement::PrintStatement;
+pub use variable_assignment_statement::VariableAssignmentStatement;
+
+use from_variants::FromVariants;
+
+#[derive(FromVariants, Debug)]
+pub enum Statement {
+	Expression(ExpressionStatement),
+	Print(PrintStatement),
+	VariableAssignment(VariableAssignmentStatement),
+}
+
+macro_rules! all_variants {
+	($expr:expr, $val_name:ident => $expr_arm:expr) => {
+		{
+		use match_any::match_any;
+		use $crate::ast::statement::*;
+		match_any!($expr, Statement::Expression($val_name) | Statement::Print($val_name) | Statement::VariableAssignment($val_name) => $expr_arm)
+		}
+	};
+}
+pub(crate) use all_variants;
+
+impl<'a, T: Iterator<Item = token::Token<'a>>> Parser<'a, T> {
+	pub fn statement(&mut self) -> Result<Statement> {
+		self.print_statement()
+	}
+}

src/ast/statement/print_statement.rs

@@ -0,0 +1,32 @@
+use itertools::PeekingNext;
+
+use super::{InnerASTParsingError, Parser, Result, Statement};
+use crate::ast::expression::expression_node::ExpressionNode;
+use crate::lexer::token::{self, Token};
+
+#[derive(Debug)]
+pub struct PrintStatement(pub ExpressionNode);
+impl PrintStatement {
+	pub fn new(expr: ExpressionNode) -> Self {
+		Self(expr)
+	}
+}
+
+impl<'a, T: Iterator<Item = token::Token<'a>>> Parser<'a, T> {
+	pub(super) fn print_statement(&mut self) -> Result<Statement> {
+		if let Some(Token { location: loc, .. }) = self
+			.token_iter
+			.peeking_next(|t| matches!(t.token_type, token::TokenType::Print))
+		{
+			let expr = self.expression()?;
+			if let token::TokenType::Semicolon = self.token_iter.peek().token_type {
+				self.token_iter.next();
+				Ok(PrintStatement::new(expr).into())
+			} else {
+				Err(loc.wrap(InnerASTParsingError::ExpectedSemi))
+			}
+		} else {
+			self.variable_assignment_statement()
+		}
+	}
+}

src/ast/statement/statement_node.rs

@@ -1,48 +0,0 @@
-use crate::ast::expression::expression_node::ExpressionNode;
-use from_variants::FromVariants;
-
-#[derive(FromVariants, Debug)]
-pub enum Statement {
-	Expression(ExpressionStatement),
-	Print(PrintStatement),
-	VariableAssignment(VariableAssignmentStatement),
-}
-
-macro_rules! all_variants {
-	($expr:expr, $val_name:ident => $expr_arm:expr) => {
-		{
-		use match_any::match_any;
-		use $crate::ast::statement::statement_node::*;
-		match_any!($expr, Statement::Expression($val_name) | Statement::Print($val_name) | Statement::VariableAssignment($val_name) => $expr_arm)
-		}
-	};
-}
-pub(crate) use all_variants;
-
-#[derive(Debug)]
-pub struct ExpressionStatement(pub ExpressionNode);
-impl ExpressionStatement {
-	pub fn new(expr: ExpressionNode) -> Self {
-		Self(expr)
-	}
-}
-
-#[derive(Debug)]
-pub struct PrintStatement(pub ExpressionNode);
-impl PrintStatement {
-	pub fn new(expr: ExpressionNode) -> Self {
-		Self(expr)
-	}
-}
-
-#[derive(Debug)]
-pub struct VariableAssignmentStatement {
-	pub var_name: String,
-	pub node: ExpressionNode,
-}
-
-impl VariableAssignmentStatement {
-	pub fn new(var_name: String, node: ExpressionNode) -> Self {
-		Self { var_name, node }
-	}
-}

src/ast/statement/statement_parser.rs

@@ -1,70 +0,0 @@
-use itertools::PeekingNext;
-
-use super::statement_node::{ExpressionStatement, PrintStatement, Statement};
-use crate::{
-	ast::{
-		parser::{InnerASTParsingError, Parser, Result},
-		statement::statement_node::VariableAssignmentStatement,
-	},
-	lexer::token::{self, Token, TokenType},
-};
-
-impl<'a, T: Iterator<Item = token::Token<'a>>> Parser<'a, T> {
-	pub fn statement(&mut self) -> Result<Statement> {
-		self.print_statement()
-	}
-
-	fn print_statement(&mut self) -> Result<Statement> {
-		if let Some(Token { location: loc, .. }) = self
-			.token_iter
-			.peeking_next(|t| matches!(t.token_type, token::TokenType::Print))
-		{
-			let expr = self.expression()?;
-			if let token::TokenType::Semicolon = self.token_iter.peek().token_type {
-				self.token_iter.next();
-				Ok(PrintStatement::new(expr).into())
-			} else {
-				Err(loc.wrap(InnerASTParsingError::ExpectedSemi))
-			}
-		} else {
-			self.variable_assignment_statement()
-		}
-	}
-
-	fn variable_assignment_statement(&mut self) -> Result<Statement> {
-		if matches!(
-			self.token_iter.peek_nth(0).token_type,
-			TokenType::Identifier(_)
-		) && matches!(self.token_iter.peek_nth(1).token_type, TokenType::Equal)
-		{
-			let ident = if let TokenType::Identifier(ident) = self.token_iter.next().token_type {
-				ident
-			} else {
-				unreachable!()
-			};
-			self.token_iter.next();
-			let expr = self.expression()?;
-
-			let token = self.token_iter.peek();
-			if let token::TokenType::Semicolon = token.token_type {
-				self.token_iter.next();
-				Ok(VariableAssignmentStatement::new(ident, expr).into())
-			} else {
-				Err(token.location.wrap(InnerASTParsingError::ExpectedSemi))
-			}
-		} else {
-			self.expression_statement()
-		}
-	}
-
-	fn expression_statement(&mut self) -> Result<Statement> {
-		let expr = self.expression()?;
-		let token = self.token_iter.peek();
-		if let TokenType::Semicolon = token.token_type {
-			self.token_iter.next();
-			Ok(ExpressionStatement::new(expr).into())
-		} else {
-			Err(token.location.wrap(InnerASTParsingError::ExpectedSemi))
-		}
-	}
-}

src/ast/statement/variable_assignment_statement.rs

@@ -0,0 +1,44 @@
+use super::Statement;
+use super::{InnerASTParsingError, Parser, Result};
+use crate::ast::expression::expression_node::ExpressionNode;
+use crate::lexer::token::{self, TokenType};
+
+#[derive(Debug)]
+pub struct VariableAssignmentStatement {
+	pub var_name: String,
+	pub node: ExpressionNode,
+}
+
+impl VariableAssignmentStatement {
+	pub fn new(var_name: String, node: ExpressionNode) -> Self {
+		Self { var_name, node }
+	}
+}
+
+impl<'a, T: Iterator<Item = token::Token<'a>>> Parser<'a, T> {
+	pub(super) fn variable_assignment_statement(&mut self) -> Result<Statement> {
+		if matches!(
+			self.token_iter.peek_nth(0).token_type,
+			TokenType::Identifier(_)
+		) && matches!(self.token_iter.peek_nth(1).token_type, TokenType::Equal)
+		{
+			let ident = if let TokenType::Identifier(ident) = self.token_iter.next().token_type {
+				ident
+			} else {
+				unreachable!()
+			};
+			self.token_iter.next();
+			let expr = self.expression()?;
+
+			let token = self.token_iter.peek();
+			if let token::TokenType::Semicolon = token.token_type {
+				self.token_iter.next();
+				Ok(VariableAssignmentStatement::new(ident, expr).into())
+			} else {
+				Err(token.location.wrap(InnerASTParsingError::ExpectedSemi))
+			}
+		} else {
+			self.expression_statement()
+		}
+	}
+}

src/interpreter/ast_walker/statement_interpreter.rs

@@ -1,15 +1,15 @@
 use super::Interpret;
 use super::{types::Value, RuntimeError};
-use crate::ast::statement::statement_node;
+use crate::ast::statement;
 use crate::interpreter::world::World;
 
-impl Interpret for statement_node::Statement {
+impl Interpret for statement::Statement {
 	fn interpret(&self, w: &mut World) -> Result<Value, RuntimeError> {
-		statement_node::all_variants!(self, n => n.interpret(w))
+		statement::all_variants!(self, n => n.interpret(w))
 	}
 }
 
-impl Interpret for statement_node::PrintStatement {
+impl Interpret for statement::PrintStatement {
 	fn interpret(&self, w: &mut World) -> Result<Value, RuntimeError> {
 		let res = self.0.interpret(w)?;
 		println!("{:?}", res);
@@ -17,13 +17,13 @@ impl Interpret for statement_node::PrintStatement {
 	}
 }
 
-impl Interpret for statement_node::ExpressionStatement {
+impl Interpret for statement::ExpressionStatement {
 	fn interpret(&self, w: &mut World) -> Result<Value, RuntimeError> {
 		self.0.interpret(w)
 	}
 }
 
-impl Interpret for statement_node::VariableAssignmentStatement {
+impl Interpret for statement::VariableAssignmentStatement {
 	fn interpret(&self, w: &mut World) -> Result<Value, RuntimeError> {
 		let expr_val = self.node.interpret(w)?;
 		// Clone for now, later this will use a GC and won't need to clone

src/interpreter/world.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::ast::statement::statement_node::Statement;
+use crate::ast::statement::Statement;
 
 use super::{
 	ast_walker::{Interpret, RuntimeError},

src/lib.rs

@@ -5,7 +5,7 @@ pub mod interpreter;
 pub mod lexer;
 
 use ast::parser::ParseAllResult;
-use ast::statement::statement_node::Statement;
+use ast::statement::Statement;
 use interpreter::ast_walker::{Interpret, RuntimeError};
 use interpreter::types::Value;
 use interpreter::world::World;