feat: add function call ast

Author: gengjiawen

interpreter/lib.rs

@@ -85,9 +85,9 @@ fn eval_expression(expression: &Expression, env: &Env) -> Result<Rc<Object>, Eva
         Expression::FUNCTION(FunctionDeclaration { params, body, .. }) => {
             return Ok(Rc::new(Object::Function(params.clone(), body.clone(), Rc::clone(env))));
         }
-        Expression::FunctionCall(func, args) => {
-            let func = eval_expression(func, &Rc::clone(env))?;
-            let args = eval_expressions(args, env)?;
+        Expression::FunctionCall(FunctionCall { callee, arguments, .. }) => {
+            let func = eval_expression(callee, &Rc::clone(env))?;
+            let args = eval_expressions(arguments, env)?;
             apply_function(&func, &args)
         }
         Expression::Index(left, index) => {

parser/ast.rs

@@ -83,6 +83,14 @@ impl fmt::Display for BlockStatement {
     }
 }
 
+// function can be Identifier or FunctionLiteral (think iife)
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, Hash, PartialEq)]
+pub struct FunctionCall {
+    pub callee: Box<Expression>,
+    pub arguments: Vec<Expression>,
+    pub span: Span,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, Eq, Hash, PartialEq)]
 pub enum Expression {
     IDENTIFIER(IDENTIFIER),
@@ -91,7 +99,7 @@ pub enum Expression {
     INFIX(BinaryExpression),
     IF(IF),
     FUNCTION(FunctionDeclaration),
-    FunctionCall(Box<Expression>, Vec<Expression>), // function can be Identifier or FunctionLiteral (think iife)
+    FunctionCall(FunctionCall),
     Index(Box<Expression>, Box<Expression>),
 }
 
@@ -161,8 +169,8 @@ impl fmt::Display for Expression {
             Expression::FUNCTION(FunctionDeclaration { params, body, .. }) => {
                 write!(f, "fn({}) {{ {} }}", params.join(", "), body)
             }
-            Expression::FunctionCall(function, args) => {
-                write!(f, "{}({})", function, format_expressions(args))
+            Expression::FunctionCall(FunctionCall { callee, arguments, .. }) => {
+                write!(f, "{}({})", callee, format_expressions(arguments))
             }
             Expression::Index(left, index) => {
                 write!(f, "({}[{}])", left, index)

parser/ast_tree_test.rs

@@ -66,4 +66,10 @@ mod tests {
         let input = "fn(x) { x };";
         test_ast_tree("test_func_declaration", input)
     }
+
+    #[test]
+    fn test_func_call() {
+        let input = "add(1, 2)";
+        test_ast_tree("test_func_call", input)
+    }
 }

parser/lib.rs

@@ -6,7 +6,7 @@ pub extern crate lexer;
 
 use lexer::token::{TokenKind, Token, Span};
 use lexer::Lexer;
-use crate::ast::{Program, Statement, Expression, Node, Literal, BlockStatement, Let, Integer, Boolean, StringType, Array, Hash, UnaryExpression, BinaryExpression, IDENTIFIER, IF, FunctionDeclaration};
+use crate::ast::{Program, Statement, Expression, Node, Literal, BlockStatement, Let, Integer, Boolean, StringType, Array, Hash, UnaryExpression, BinaryExpression, IDENTIFIER, IF, FunctionDeclaration, FunctionCall};
 use crate::precedences::{Precedence, get_token_precedence};
 
 type ParseError = String;
@@ -365,8 +365,17 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_fn_call_expression(&mut self, expr: Expression) -> Result<Expression, ParseError> {
+        let start = self.current_token.span.start;
         let (arguments, ..) = self.parse_expression_list(&TokenKind::RPAREN)?;
-        Ok(Expression::FunctionCall(Box::new(expr), arguments))
+        let end = self.current_token.span.end;
+        Ok(Expression::FunctionCall(FunctionCall {
+            callee: Box::new(expr),
+            arguments,
+            span: Span {
+                start,
+                end,
+            }
+        }))
     }
 
     fn parse_expression_list(&mut self, end: &TokenKind) -> Result<(Vec<Expression>, Span), ParseError> {

parser/snapshots/parser__ast_tree_test__tests__test_func_call.snap

@@ -0,0 +1,50 @@
+---
+source: parser/ast_tree_test.rs
+expression: let_ast
+---
+{
+  "Program": {
+    "body": [
+      {
+        "type": "Expr",
+        "FunctionCall": {
+          "callee": {
+            "IDENTIFIER": {
+              "name": "add",
+              "span": {
+                "start": 0,
+                "end": 3
+              }
+            }
+          },
+          "arguments": [
+            {
+              "LITERAL": {
+                "type": "Integer",
+                "raw": 1,
+                "span": {
+                  "start": 4,
+                  "end": 5
+                }
+              }
+            },
+            {
+              "LITERAL": {
+                "type": "Integer",
+                "raw": 2,
+                "span": {
+                  "start": 7,
+                  "end": 8
+                }
+              }
+            }
+          ],
+          "span": {
+            "start": 3,
+            "end": 9
+          }
+        }
+      }
+    ]
+  }
+}