feat: adding defining and calling functions

DeveloperC286 · DeveloperC286 · commit e27c1d973e16 · 2021-11-21T18:28:28.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "monkey_interpreter"
-version = "0.14.0"
+version = "0.15.0"
 description = "Implementation of an interpreter for the Monkey language written in Rust, currently under active development."
 authors = ["C <DeveloperC@protonmail.com>"]
 edition = "2021"
diff --git a/README.md b/README.md
@@ -1,5 +1,5 @@
 # Monkey Interpreter
-[![pipeline status](https://img.shields.io/badge/Version-0.14.0-blue)](https://gitlab.com/DeveloperC/monkey_interpreter/commits/master) [![pipeline status](https://gitlab.com/DeveloperC/monkey_interpreter/badges/master/pipeline.svg)](https://gitlab.com/DeveloperC/monkey_interpreter/commits/master) [![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org) [![License: AGPL v3](https://img.shields.io/badge/License-AGPLv3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
+[![pipeline status](https://img.shields.io/badge/Version-0.15.0-blue)](https://gitlab.com/DeveloperC/monkey_interpreter/commits/master) [![pipeline status](https://gitlab.com/DeveloperC/monkey_interpreter/badges/master/pipeline.svg)](https://gitlab.com/DeveloperC/monkey_interpreter/commits/master) [![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org) [![License: AGPL v3](https://img.shields.io/badge/License-AGPLv3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
 
 
 ![The Monkey Programming Language Logo](https://cloud.githubusercontent.com/assets/1013641/22617482/9c60c27c-eb09-11e6-9dfa-b04c7fe498ea.png)
diff --git a/src/evaluator/expression/call/mod.rs b/src/evaluator/expression/call/mod.rs
@@ -0,0 +1,40 @@
+use crate::evaluator::model::object::{ErrorType, Object};
+use crate::evaluator::Evaluator;
+use crate::syntax_analysis::model::abstract_syntax_tree::syntax_tree_node::Expression;
+
+impl Evaluator {
+    pub(super) fn evaluate_call_expression(
+        &mut self,
+        function: Expression,
+        arguments: Vec<Expression>,
+    ) -> Object {
+        match self.evaluate_expression(function) {
+            Object::Function { parameters, block } => {
+                self.environment.push();
+
+                for (argument, parameter_identifier) in arguments.into_iter().zip(parameters) {
+                    let argument_evaluation = self.evaluate_expression(argument);
+
+                    if let Object::Error { error_type } = argument_evaluation.clone() {
+                        self.environment.pop();
+                        return Object::Error { error_type };
+                    }
+
+                    self.environment
+                        .set(parameter_identifier, argument_evaluation);
+                }
+
+                let block_call_evaluation = self.evaluate_block(block);
+                self.environment.pop();
+                block_call_evaluation
+            }
+            Object::Error { error_type } => Object::Error { error_type },
+            _ => Object::Error {
+                error_type: ErrorType::UncallableObject,
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/src/evaluator/expression/call/tests/mod.rs b/src/evaluator/expression/call/tests/mod.rs
@@ -0,0 +1,30 @@
+use rstest::rstest;
+
+#[rstest(
+    code,
+    snapshot_name,
+    case(
+        "let identity = fn(x) { x; }; identity(5);",
+        "test_evaluator_call_nodes_case1"
+    ),
+    case(
+        "let identity = fn(x) { return x; }; identity(5);",
+        "test_evaluator_call_nodes_case2"
+    ),
+    case(
+        "let double = fn(x) { x * 2 }; double(5);",
+        "test_evaluator_call_nodes_case3"
+    ),
+    case(
+        "let add = fn(x, y) { x + y }; add(2, 3);",
+        "test_evaluator_call_nodes_case4"
+    ),
+    case(
+        "let add = fn(x, y) { x + y }; add(1, add(2, 3));",
+        "test_evaluator_call_nodes_case5"
+    ),
+    case("fn(y) { y }(13)", "test_evaluator_call_nodes_case6")
+)]
+fn test_evaluator_call_nodes(code: &str, snapshot_name: &str) {
+    assert_expected_returned_object!(code, snapshot_name);
+}
diff --git a/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case1.snap b/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case1.snap
@@ -0,0 +1,8 @@
+---
+source: src/evaluator/expression/call/tests/mod.rs
+expression: "evaluator.evaluate(crate::syntax_analysis::SyntaxAnalysis::from(crate::lexical_analysis::LexicalAnalysis::from(code)))"
+
+---
+Integer {
+    value: 5,
+}
diff --git a/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case2.snap b/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case2.snap
@@ -0,0 +1,8 @@
+---
+source: src/evaluator/expression/call/tests/mod.rs
+expression: "evaluator.evaluate(crate::syntax_analysis::SyntaxAnalysis::from(crate::lexical_analysis::LexicalAnalysis::from(code)))"
+
+---
+Integer {
+    value: 5,
+}
diff --git a/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case3.snap b/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case3.snap
@@ -0,0 +1,8 @@
+---
+source: src/evaluator/expression/call/tests/mod.rs
+expression: "evaluator.evaluate(crate::syntax_analysis::SyntaxAnalysis::from(crate::lexical_analysis::LexicalAnalysis::from(code)))"
+
+---
+Integer {
+    value: 10,
+}
diff --git a/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case4.snap b/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case4.snap
@@ -0,0 +1,8 @@
+---
+source: src/evaluator/expression/call/tests/mod.rs
+expression: "evaluator.evaluate(crate::syntax_analysis::SyntaxAnalysis::from(crate::lexical_analysis::LexicalAnalysis::from(code)))"
+
+---
+Integer {
+    value: 5,
+}
diff --git a/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case5.snap b/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case5.snap
@@ -0,0 +1,8 @@
+---
+source: src/evaluator/expression/call/tests/mod.rs
+expression: "evaluator.evaluate(crate::syntax_analysis::SyntaxAnalysis::from(crate::lexical_analysis::LexicalAnalysis::from(code)))"
+
+---
+Integer {
+    value: 6,
+}
diff --git a/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case6.snap b/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__call__tests__test_evaluator_call_nodes_case6.snap
@@ -0,0 +1,6 @@
+---
+source: src/evaluator/expression/call/tests/mod.rs
+expression: "evaluator.evaluate(crate::syntax_analysis::SyntaxAnalysis::from(crate::lexical_analysis::LexicalAnalysis::from(code)))"
+
+---
+Null
diff --git a/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__function__tests__test_evaluator_function_nodes_case1.snap b/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__function__tests__test_evaluator_function_nodes_case1.snap
@@ -0,0 +1,29 @@
+---
+source: src/evaluator/expression/function/tests/mod.rs
+expression: "evaluator.evaluate(crate::syntax_analysis::SyntaxAnalysis::from(crate::lexical_analysis::LexicalAnalysis::from(code)))"
+
+---
+Function {
+    parameters: [
+        Identifier {
+            identifier: "x",
+        },
+    ],
+    block: Block {
+        nodes: [
+            Expression {
+                expression: Infix {
+                    left_hand: Identifier {
+                        identifier: "x",
+                    },
+                    operator_token: Plus,
+                    right_hand: Integer {
+                        integer_token: Integer {
+                            literal: "3",
+                        },
+                    },
+                },
+            },
+        ],
+    },
+}
diff --git a/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__function__tests__test_evaluator_function_nodes_case2.snap b/src/evaluator/expression/call/tests/snapshots/monkey_interpreter__evaluator__expression__function__tests__test_evaluator_function_nodes_case2.snap
@@ -0,0 +1,30 @@
+---
+source: src/evaluator/expression/function/tests/mod.rs
+expression: "evaluator.evaluate(crate::syntax_analysis::SyntaxAnalysis::from(crate::lexical_analysis::LexicalAnalysis::from(code)))"
+
+---
+Function {
+    parameters: [
+        Identifier {
+            identifier: "x",
+        },
+        Identifier {
+            identifier: "y",
+        },
+    ],
+    block: Block {
+        nodes: [
+            Expression {
+                expression: Infix {
+                    left_hand: Identifier {
+                        identifier: "x",
+                    },
+                    operator_token: Plus,
+                    right_hand: Identifier {
+                        identifier: "y",
+                    },
+                },
+            },
+        ],
+    },
+}
diff --git a/src/evaluator/expression/function/mod.rs b/src/evaluator/expression/function/mod.rs
@@ -0,0 +1,16 @@
+use crate::evaluator::model::object::Object;
+use crate::evaluator::Evaluator;
+use crate::syntax_analysis::model::abstract_syntax_tree::syntax_tree_node::Block;
+
+impl Evaluator {
+    pub(super) fn evaluate_function_expression(
+        &self,
+        parameters: Vec<String>,
+        block: Block,
+    ) -> Object {
+        Object::Function { parameters, block }
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/src/evaluator/expression/function/tests/mod.rs b/src/evaluator/expression/function/tests/mod.rs
@@ -0,0 +1,11 @@
+use rstest::rstest;
+
+#[rstest(
+    code,
+    snapshot_name,
+    case("fn(x) { x + 3 }", "test_evaluator_function_nodes_case1"),
+    case("fn(x,y) { x + y; };", "test_evaluator_function_nodes_case2")
+)]
+fn test_evaluator_function_nodes(code: &str, snapshot_name: &str) {
+    assert_expected_returned_object!(code, snapshot_name);
+}
diff --git a/src/evaluator/expression/function/tests/snapshots/monkey_interpreter__evaluator__expression__function__tests__test_evaluator_function_nodes_case1.snap b/src/evaluator/expression/function/tests/snapshots/monkey_interpreter__evaluator__expression__function__tests__test_evaluator_function_nodes_case1.snap
@@ -0,0 +1,27 @@
+---
+source: src/evaluator/expression/function/tests/mod.rs
+expression: "evaluator.evaluate(crate::syntax_analysis::SyntaxAnalysis::from(crate::lexical_analysis::LexicalAnalysis::from(code)))"
+
+---
+Function {
+    parameters: [
+        "x",
+    ],
+    block: Block {
+        nodes: [
+            Expression {
+                expression: Infix {
+                    left_hand: Identifier {
+                        identifier: "x",
+                    },
+                    operator_token: Plus,
+                    right_hand: Integer {
+                        integer_token: Integer {
+                            literal: "3",
+                        },
+                    },
+                },
+            },
+        ],
+    },
+}
diff --git a/src/evaluator/expression/function/tests/snapshots/monkey_interpreter__evaluator__expression__function__tests__test_evaluator_function_nodes_case2.snap b/src/evaluator/expression/function/tests/snapshots/monkey_interpreter__evaluator__expression__function__tests__test_evaluator_function_nodes_case2.snap
@@ -0,0 +1,26 @@
+---
+source: src/evaluator/expression/function/tests/mod.rs
+expression: "evaluator.evaluate(crate::syntax_analysis::SyntaxAnalysis::from(crate::lexical_analysis::LexicalAnalysis::from(code)))"
+
+---
+Function {
+    parameters: [
+        "x",
+        "y",
+    ],
+    block: Block {
+        nodes: [
+            Expression {
+                expression: Infix {
+                    left_hand: Identifier {
+                        identifier: "x",
+                    },
+                    operator_token: Plus,
+                    right_hand: Identifier {
+                        identifier: "y",
+                    },
+                },
+            },
+        ],
+    },
+}
diff --git a/src/evaluator/expression/mod.rs b/src/evaluator/expression/mod.rs
@@ -3,6 +3,8 @@ use crate::evaluator::Evaluator;
 use crate::syntax_analysis::model::abstract_syntax_tree::syntax_tree_node::*;
 
 mod boolean;
+mod call;
+mod function;
 mod if_expression;
 mod infix;
 mod integer;
@@ -27,12 +29,14 @@ impl Evaluator {
                 consequence,
                 alternative,
             } => self.evaluate_if_expression(*condition, *consequence, *alternative),
-            Expression::Identifier { identifier } => self
-                .variables
-                .get(&identifier)
-                .unwrap_or(&Object::Null)
-                .clone(),
-            _ => Object::Null,
+            Expression::Identifier { identifier } => self.environment.get(&identifier),
+            Expression::Function { parameters, block } => {
+                self.evaluate_function_expression(parameters, *block)
+            }
+            Expression::Call {
+                function,
+                arguments,
+            } => self.evaluate_call_expression(*function, arguments),
         }
     }
 }
diff --git a/src/evaluator/mod.rs b/src/evaluator/mod.rs
@@ -1,10 +1,9 @@
+use crate::evaluator::model::environment::Environment;
 use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::abstract_syntax_tree::syntax_tree_node::*;
 use crate::syntax_analysis::model::abstract_syntax_tree::AbstractSyntaxTree;
 
-use std::collections::HashMap;
-
-pub(crate) mod model;
+mod model;
 
 #[cfg(test)]
 #[macro_use]
@@ -13,15 +12,14 @@ mod tests;
 mod expression;
 mod statement;
 
-#[derive(Debug)]
 pub(crate) struct Evaluator {
-    variables: HashMap<String, Object>,
+    environment: Environment,
 }
 
 impl Evaluator {
     pub(crate) fn new() -> Evaluator {
         Evaluator {
-            variables: HashMap::new(),
+            environment: Environment::new(),
         }
     }
 
diff --git a/src/evaluator/model/environment/mod.rs b/src/evaluator/model/environment/mod.rs
diff --git a/src/evaluator/model/mod.rs b/src/evaluator/model/mod.rs
diff --git a/src/evaluator/model/object/mod.rs b/src/evaluator/model/object/mod.rs
diff --git a/src/evaluator/statement/let_statement/mod.rs b/src/evaluator/statement/let_statement/mod.rs
diff --git a/src/syntax_analysis/expression/function_expression/mod.rs b/src/syntax_analysis/expression/function_expression/mod.rs
diff --git a/src/syntax_analysis/expression/function_expression/tests/snapshots/monkey_interpreter__syntax_analysis__expression__function_expression__tests__test_syntax_analysis_for_function_expression_case1.snap b/src/syntax_analysis/expression/function_expression/tests/snapshots/monkey_interpreter__syntax_analysis__expression__function_expression__tests__test_syntax_analysis_for_function_expression_case1.snap
diff --git a/src/syntax_analysis/expression/function_expression/tests/snapshots/monkey_interpreter__syntax_analysis__expression__function_expression__tests__test_syntax_analysis_for_function_expression_case3.snap b/src/syntax_analysis/expression/function_expression/tests/snapshots/monkey_interpreter__syntax_analysis__expression__function_expression__tests__test_syntax_analysis_for_function_expression_case3.snap
diff --git a/src/syntax_analysis/model/abstract_syntax_tree/syntax_tree_node/mod.rs b/src/syntax_analysis/model/abstract_syntax_tree/syntax_tree_node/mod.rs
