feat: add func name in parser

Author: gengjiawen

parser/ast.rs

@@ -152,6 +152,7 @@ pub struct FunctionDeclaration {
     pub params: Vec<IDENTIFIER>,
     pub body: BlockStatement,
     pub span: Span,
+    pub name: String,
 }
 
 // function can be Identifier or FunctionLiteral (think iife)
@@ -189,13 +190,13 @@ impl fmt::Display for Expression {
                     write!(f, "if {} {{ {} }}", condition, consequent,)
                 }
             }
-            Expression::FUNCTION(FunctionDeclaration { params, body, .. }) => {
+            Expression::FUNCTION(FunctionDeclaration { name, params, body, .. }) => {
                 let func_params = params
                     .iter()
                     .map(|stmt| stmt.to_string())
                     .collect::<Vec<String>>()
                     .join(", ");
-                write!(f, "fn({}) {{ {} }}", func_params, body)
+                write!(f, "fn {}({}) {{ {} }}", name, func_params, body)
             }
             Expression::FunctionCall(FunctionCall { callee, arguments, .. }) => {
                 write!(f, "{}({})", callee, format_expressions(arguments))

parser/ast_tree_test.rs

@@ -100,4 +100,10 @@ mod tests {
         let input = "a[1]";
         test_ast_tree("test_index", input)
     }
+
+    #[test]
+    fn test_func_with_name() {
+        let input = "let my_func = fn(x) { x };";
+        test_ast_tree("test_func_with_name", input)
+    }
 }

parser/lib.rs

@@ -97,15 +97,24 @@ impl<'a> Parser<'a> {
         self.next_token();
 
         let name = self.current_token.clone();
+        let mut identifier_name = "".to_string();
         match &self.current_token.kind {
-            TokenKind::IDENTIFIER { name: _ } => {}
+            TokenKind::IDENTIFIER { name } => {
+                identifier_name = name.to_string();
+            }
             _ => return Err(format!("{} not an identifier", self.current_token)),
         };
 
         self.expect_peek(&TokenKind::ASSIGN)?;
         self.next_token();
 
-        let value = self.parse_expression(Precedence::LOWEST)?.0;
+        let mut value = self.parse_expression(Precedence::LOWEST)?.0;
+        match value {
+            Expression::FUNCTION(ref mut f) => {
+                f.name = identifier_name;
+            }
+            _ => {}
+        }
 
         if self.peek_token_is(&TokenKind::SEMICOLON) {
             self.next_token();
@@ -330,6 +339,7 @@ impl<'a> Parser<'a> {
             params,
             body: function_body,
             span: Span { start, end },
+            name: "".to_string(),
         }))
     }
 

parser/snapshots/parser__ast_tree_test__tests__test_func_declaration.snap

@@ -38,7 +38,8 @@ expression: "fn(x) { x };"
         "span": {
           "start": 0,
           "end": 11
-        }
+        },
+        "name": ""
       }
     ],
     "span": {

parser/snapshots/parser__ast_tree_test__tests__test_func_with_name.snap

@@ -0,0 +1,69 @@
+---
+source: parser/ast_tree_test.rs
+expression: "let my_func = fn(x) { x };"
+---
+{
+  "Program": {
+    "type": "Program",
+    "body": [
+      {
+        "type": "Let",
+        "identifier": {
+          "kind": {
+            "type": "IDENTIFIER",
+            "value": {
+              "name": "my_func"
+            }
+          },
+          "span": {
+            "start": 4,
+            "end": 11
+          }
+        },
+        "expr": {
+          "type": "FunctionDeclaration",
+          "params": [
+            {
+              "type": "IDENTIFIER",
+              "name": "x",
+              "span": {
+                "start": 17,
+                "end": 18
+              }
+            }
+          ],
+          "body": {
+            "type": "BlockStatement",
+            "body": [
+              {
+                "type": "IDENTIFIER",
+                "name": "x",
+                "span": {
+                  "start": 22,
+                  "end": 23
+                }
+              }
+            ],
+            "span": {
+              "start": 20,
+              "end": 25
+            }
+          },
+          "span": {
+            "start": 14,
+            "end": 25
+          },
+          "name": "my_func"
+        },
+        "span": {
+          "start": 0,
+          "end": 26
+        }
+      }
+    ],
+    "span": {
+      "start": 0,
+      "end": 27
+    }
+  }
+}