refactor: module structure visibility

src/evaluator/model/environment/mod.rs → src/evaluator/environment/mod.rs

@@ -1,38 +1,38 @@
 use std::collections::BTreeMap;
 
-use crate::evaluator::model::object::Object;
+use crate::evaluator::Object;
 
 #[derive(Debug, Clone)]
-pub(crate) struct Environment {
+pub(super) struct Environment {
     variables: BTreeMap<String, Object>,
     sub_environment: Option<Box<Environment>>,
 }
 
 impl Environment {
-    pub(crate) fn new() -> Environment {
+    pub(super) fn new() -> Environment {
         Environment {
             variables: BTreeMap::new(),
             sub_environment: None,
         }
     }
 
-    pub(crate) fn push(&mut self) {
+    pub(super) fn push(&mut self) {
         self.sub_environment = Some(Box::new(self.clone()));
         self.variables = BTreeMap::new();
     }
 
-    pub(crate) fn pop(&mut self) {
+    pub(super) fn pop(&mut self) {
         if let Some(sub_environment) = self.sub_environment.clone() {
             self.variables = sub_environment.variables;
             self.sub_environment = sub_environment.sub_environment;
         }
     }
 
-    pub(crate) fn set(&mut self, identifier: String, value: Object) {
+    pub(super) fn set(&mut self, identifier: String, value: Object) {
         self.variables.insert(identifier, value);
     }
 
-    pub(crate) fn get<T: AsRef<str>>(&self, identifier: T) -> Object {
+    pub(super) fn get<T: AsRef<str>>(&self, identifier: T) -> Object {
         match self.variables.get(identifier.as_ref()) {
             Some(value) => value.clone(),
             None => {

src/evaluator/expression/boolean/mod.rs

@@ -1,5 +1,5 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
+use crate::evaluator::Object;
 
 impl Evaluator {
     pub(super) fn evaluate_boolean(&self, literal: bool) -> anyhow::Result<Object> {

src/evaluator/expression/call/mod.rs

@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
+use crate::evaluator::Object;
+use crate::syntax_analysis::Expression;
 
 impl Evaluator {
     pub(super) fn evaluate_call_expression(

src/evaluator/expression/function/mod.rs

@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::Block;
+use crate::evaluator::Object;
+use crate::syntax_analysis::Block;
 
 impl Evaluator {
     pub(super) fn evaluate_function_expression(

src/evaluator/expression/if_expression/mod.rs

@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::{Block, Expression};
+use crate::evaluator::Object;
+use crate::syntax_analysis::{Block, Expression};
 
 impl Evaluator {
     pub(super) fn evaluate_if_expression(

src/evaluator/expression/infix/mod.rs

@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::{Expression, InfixOperator};
+use crate::evaluator::Object;
+use crate::syntax_analysis::{Expression, InfixOperator};
 
 impl Evaluator {
     pub(super) fn evaluate_infix_expression(

src/evaluator/expression/integer/mod.rs

@@ -1,5 +1,5 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
+use crate::evaluator::Object;
 
 impl Evaluator {
     pub(super) fn evaluate_integer(&self, literal: i64) -> anyhow::Result<Object> {

src/evaluator/expression/mod.rs

@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::*;
+use crate::evaluator::Object;
+use crate::syntax_analysis::*;
 
 mod boolean;
 mod call;
@@ -12,7 +12,7 @@ mod prefix;
 mod string;
 
 impl Evaluator {
-    pub(crate) fn evaluate_expression(&mut self, expression: Expression) -> anyhow::Result<Object> {
+    pub(super) fn evaluate_expression(&mut self, expression: Expression) -> anyhow::Result<Object> {
         match expression {
             Expression::Integer { literal } => self.evaluate_integer(literal),
             Expression::String { literal } => self.evaluate_string(literal),

src/evaluator/expression/prefix/mod.rs

@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
+use crate::evaluator::Object;
+use crate::syntax_analysis::Expression;
 
 impl Evaluator {
     pub(super) fn evaluate_not_prefix_expression(

src/evaluator/expression/string/mod.rs

@@ -1,5 +1,5 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
+use crate::evaluator::Object;
 
 impl Evaluator {
     pub(super) fn evaluate_string(&self, string: String) -> anyhow::Result<Object> {

src/evaluator/mod.rs

@@ -1,12 +1,13 @@
-use crate::evaluator::model::environment::Environment;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::*;
-
-pub(crate) mod model;
+use crate::evaluator::environment::Environment;
+use crate::syntax_analysis::*;
 
+mod environment;
 mod expression;
+mod object;
 mod statement;
 
+pub use object::Object;
+
 #[derive(Debug)]
 pub(crate) struct Evaluator {
     environment: Environment,

src/evaluator/model/object/mod.rs → src/evaluator/object/mod.rs

@@ -1,9 +1,9 @@
 use std::fmt;
 
-use crate::syntax_analysis::model::syntax_tree_node::Block;
+use crate::syntax_analysis::Block;
 
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) enum Object {
+pub enum Object {
     Return {
         value: Box<Object>,
     },

src/evaluator/statement/let_statement/mod.rs

@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::*;
+use crate::evaluator::Object;
+use crate::syntax_analysis::*;
 
 impl Evaluator {
     pub(super) fn evaluate_let_statement(

src/evaluator/statement/mod.rs

@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::*;
+use crate::evaluator::Object;
+use crate::syntax_analysis::*;
 
 mod let_statement;
 mod return_statement;

src/evaluator/statement/return_statement/mod.rs

@@ -1,6 +1,6 @@
 use crate::evaluator::Evaluator;
-use crate::evaluator::model::object::Object;
-use crate::syntax_analysis::model::syntax_tree_node::*;
+use crate::evaluator::Object;
+use crate::syntax_analysis::*;
 
 impl Evaluator {
     pub(super) fn evaluate_return_statement(

src/lexical_analysis/mod.rs

@@ -3,9 +3,9 @@ use std::str::Chars;
 
 use log::{debug, info, trace};
 
-use crate::lexical_analysis::model::token::Token;
+mod token;
 
-pub(crate) mod model;
+pub use token::Token;
 
 pub(crate) struct LexicalAnalysis<'a> {
     source_code: Peekable<Chars<'a>>,

src/lexical_analysis/model/token/mod.rs → src/lexical_analysis/token/mod.rs

@@ -1,5 +1,5 @@
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) enum Token {
+pub enum Token {
     // Identifiers
     Identifier { literal: String },
 

src/syntax_analysis/expression/function_expression/mod.rs

@@ -1,11 +1,11 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
+use crate::syntax_analysis::Expression;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_function_expression(&mut self) -> anyhow::Result<Expression> {
+    pub(super) fn parse_function_expression(&mut self) -> anyhow::Result<Expression> {
         debug!("Parsing a function expression.");
 
         // parse function expression

src/syntax_analysis/expression/grouped_expression/mod.rs

@@ -1,12 +1,12 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
+use crate::syntax_analysis::Expression;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
+use crate::syntax_analysis::expression_precedence::ExpressionPrecedence;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_grouped_expression(&mut self) -> anyhow::Result<Expression> {
+    pub(super) fn parse_grouped_expression(&mut self) -> anyhow::Result<Expression> {
         debug!("Parsing a grouped expression.");
 
         assert_token!(

src/syntax_analysis/expression/if_expression/mod.rs

@@ -1,12 +1,12 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
+use crate::syntax_analysis::Expression;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
+use crate::syntax_analysis::expression_precedence::ExpressionPrecedence;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_if_expression(&mut self) -> anyhow::Result<Expression> {
+    pub(super) fn parse_if_expression(&mut self) -> anyhow::Result<Expression> {
         debug!("Parsing a if expression.");
 
         // parse if expression

src/syntax_analysis/expression/mod.rs

@@ -1,10 +1,10 @@
 use anyhow::Context;
 use log::{debug, trace};
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
-use crate::syntax_analysis::model::syntax_tree_node::{Expression, SyntaxTreeNode};
+use crate::syntax_analysis::expression_precedence::ExpressionPrecedence;
+use crate::syntax_analysis::{Expression, SyntaxTreeNode};
 
 mod function_expression;
 mod grouped_expression;
@@ -13,13 +13,13 @@ mod pratt_parsing;
 mod utilities;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn get_expression_node(&mut self) -> anyhow::Result<SyntaxTreeNode> {
+    pub(super) fn get_expression_node(&mut self) -> anyhow::Result<SyntaxTreeNode> {
         let expression = self.get_expression(ExpressionPrecedence::Lowest)?;
         semicolon!(self);
         Ok(SyntaxTreeNode::Expression { expression })
     }
 
-    pub(crate) fn get_expression(
+    pub(super) fn get_expression(
         &mut self,
         expression_precedence: ExpressionPrecedence,
     ) -> anyhow::Result<Expression> {

src/syntax_analysis/expression/pratt_parsing/call_expression/mod.rs

@@ -1,10 +1,10 @@
 use log::debug;
 
+use crate::syntax_analysis::Expression;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_call_expression(
+    pub(super) fn parse_call_expression(
         &mut self,
         function: Expression,
     ) -> anyhow::Result<Expression> {

src/syntax_analysis/expression/pratt_parsing/infix_expression/mod.rs

@@ -1,12 +1,12 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::get_infix_operator_precedence;
-use crate::syntax_analysis::model::syntax_tree_node::{Expression, InfixOperator};
+use crate::syntax_analysis::expression_precedence::get_infix_operator_precedence;
+use crate::syntax_analysis::{Expression, InfixOperator};
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn parse_infix_expression(
+    pub(super) fn parse_infix_expression(
         &mut self,
         left_hand: Expression,
     ) -> anyhow::Result<Expression> {

src/syntax_analysis/expression/pratt_parsing/mod.rs

@@ -1,15 +1,15 @@
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
+use crate::syntax_analysis::Expression;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::{
+use crate::syntax_analysis::expression_precedence::{
     ExpressionPrecedence, get_current_expression_precedence,
 };
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
 
 mod call_expression;
 mod infix_expression;
 
 impl SyntaxAnalysis<'_> {
-    pub(crate) fn pratt_parsing(
+    pub(super) fn pratt_parsing(
         &mut self,
         mut expression: Expression,
         minimum_expression_precedence: ExpressionPrecedence,

src/syntax_analysis/expression/utilities/mod.rs

@@ -1,9 +1,9 @@
 use log::debug;
 
-use crate::lexical_analysis::model::token::Token;
+use crate::lexical_analysis::Token;
 use crate::syntax_analysis::SyntaxAnalysis;
-use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
-use crate::syntax_analysis::model::syntax_tree_node::{Block, Expression};
+use crate::syntax_analysis::expression_precedence::ExpressionPrecedence;
+use crate::syntax_analysis::{Block, Expression};
 
 impl SyntaxAnalysis<'_> {
     pub(super) fn parse_block(&mut self) -> anyhow::Result<Block> {

src/syntax_analysis/model/expression_precedence/mod.rs → src/syntax_analysis/expression_precedence/mod.rs

@@ -1,10 +1,10 @@
 use log::trace;
 
-use crate::lexical_analysis::model::token::Token;
-use crate::syntax_analysis::model::syntax_tree_node::InfixOperator;
+use crate::lexical_analysis::Token;
+use crate::syntax_analysis::InfixOperator;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub(crate) enum ExpressionPrecedence {
+pub(super) enum ExpressionPrecedence {
     Lowest,
     Equals,
     LesserOrGreater,
@@ -14,7 +14,7 @@ pub(crate) enum ExpressionPrecedence {
     Call,
 }
 
-pub(crate) fn get_current_expression_precedence(token: &Token) -> ExpressionPrecedence {
+pub(super) fn get_current_expression_precedence(token: &Token) -> ExpressionPrecedence {
     match token {
         Token::Equals => ExpressionPrecedence::Equals,
         Token::NotEquals => ExpressionPrecedence::Equals,
@@ -32,7 +32,7 @@ pub(crate) fn get_current_expression_precedence(token: &Token) -> ExpressionPrec
     }
 }
 
-pub(crate) fn get_infix_operator_precedence(operator: &InfixOperator) -> ExpressionPrecedence {
+pub(super) fn get_infix_operator_precedence(operator: &InfixOperator) -> ExpressionPrecedence {
     match operator {
         InfixOperator::Equals | InfixOperator::NotEquals => ExpressionPrecedence::Equals,
         InfixOperator::LesserThan | InfixOperator::GreaterThan => {