feat: refactor function params to IDENTIFIER type.

close #53.

Author: gengjiawen

interpreter/lib.rs

@@ -126,7 +126,7 @@ fn apply_function(function: &Rc<Object>, args: &Vec<Rc<Object>>) -> Result<Rc<Ob
             let mut env = Environment::new_enclosed_environment(&env);
 
             params.iter().enumerate().for_each(|(i, param)| {
-                env.set(param.clone(), args[i].clone());
+                env.set(param.name.clone(), args[i].clone());
             });
 
             let evaluated = eval_block_statements(&body.body, &Rc::new(RefCell::new(env)))?;

interpreter/object.rs

@@ -2,7 +2,7 @@ use std::fmt;
 use std::fmt::Formatter;
 use std::rc::Rc;
 use crate::environment::Env;
-use parser::ast::BlockStatement;
+use parser::ast::{BlockStatement, IDENTIFIER};
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 
@@ -18,7 +18,7 @@ pub enum Object {
     Hash(HashMap<Rc<Object>, Rc<Object>>),
     Null,
     ReturnValue(Rc<Object>),
-    Function(Vec<String>, BlockStatement, Env),
+    Function(Vec<IDENTIFIER>, BlockStatement, Env),
     Builtin(BuiltinFunc),
     Error(String),
 }
@@ -32,7 +32,13 @@ impl fmt::Display for Object {
             Object::Null => write!(f, "null"),
             Object::ReturnValue(expr) => write!(f, "{}", expr),
             Object::Function(params, body,  _env) => {
-                write!(f, "fn({}) {{ {} }}", params.join(", "), body)
+                let func_params =
+                    params
+                        .iter()
+                        .map(|stmt| stmt.to_string())
+                        .collect::<Vec<String>>()
+                        .join(", ");
+                write!(f, "fn({}) {{ {} }}", func_params, body)
             },
             Object::Builtin(_) => write!(f, "[builtin function]"),
             Object::Error(e) => write!(f, "{}", e),

parser/ast.rs

@@ -116,6 +116,12 @@ pub struct IDENTIFIER {
     pub span: Span,
 }
 
+impl fmt::Display for IDENTIFIER {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        write!(f, "{}", &self.name)
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, Eq, Hash, PartialEq)]
 #[serde(tag = "type")]
 pub struct UnaryExpression {
@@ -145,7 +151,7 @@ pub struct IF {
 #[derive(Clone, Debug, Serialize, Deserialize, Eq, Hash, PartialEq)]
 #[serde(tag = "type")]
 pub struct FunctionDeclaration {
-    pub params: Vec<String>,
+    pub params: Vec<IDENTIFIER>,
     pub body: BlockStatement,
     pub span: Span,
 }
@@ -195,7 +201,14 @@ impl fmt::Display for Expression {
                 }
             }
             Expression::FUNCTION(FunctionDeclaration { params, body, .. }) => {
-                write!(f, "fn({}) {{ {} }}", params.join(", "), body)
+                let func_params =
+                    params
+                        .iter()
+                        .map(|stmt| stmt.to_string())
+                        .collect::<Vec<String>>()
+                        .join(", ")
+                    ;
+                write!(f, "fn({}) {{ {} }}", func_params, body)
             }
             Expression::FunctionCall(FunctionCall { callee, arguments, .. }) => {
                 write!(f, "{}({})", callee, format_expressions(arguments))

parser/lib.rs

@@ -345,7 +345,7 @@ impl<'a> Parser<'a> {
         let end = self.current_token.span.end;
 
         Ok(Expression::FUNCTION(FunctionDeclaration {
-            params: params,
+            params,
             body: function_body,
             span: Span {
                 start,
@@ -354,7 +354,7 @@ impl<'a> Parser<'a> {
         }))
     }
 
-    fn parse_fn_parameters(&mut self) -> Result<Vec<String>, ParseError> {
+    fn parse_fn_parameters(&mut self) -> Result<Vec<IDENTIFIER>, ParseError> {
         let mut params = Vec::new();
         if self.peek_token_is(&TokenKind::RPAREN) {
             self.next_token();
@@ -364,15 +364,21 @@ impl<'a> Parser<'a> {
         self.next_token();
 
         match &self.current_token.kind {
-            TokenKind::IDENTIFIER { name } => params.push(name.clone()),
+            TokenKind::IDENTIFIER { name } => params.push(IDENTIFIER {
+                name: name.clone(),
+                span: self.current_token.span.clone(),
+             }),
             token => return Err(format!("expected function params  to be an identifier, got {}", token))
         }
 
         while self.peek_token_is(&TokenKind::COMMA) {
             self.next_token();
             self.next_token();
             match &self.current_token.kind {
-                TokenKind::IDENTIFIER { name } => params.push(name.clone()),
+                TokenKind::IDENTIFIER { name } => params.push(IDENTIFIER {
+                    name: name.clone(),
+                    span: self.current_token.span.clone(),
+                }),
                 token => return Err(format!("expected function params  to be an identifier, got {}", token))
             }
         }

parser/snapshots/parser__ast_tree_test__tests__test_func_declaration.snap

@@ -9,7 +9,14 @@ expression: "fn(x) { x };"
       {
         "type": "FunctionDeclaration",
         "params": [
-          "x"
+          {
+            "type": "IDENTIFIER",
+            "name": "x",
+            "span": {
+              "start": 3,
+              "end": 4
+            }
+          }
         ],
         "body": {
           "type": "BlockStatement",