feat: add index ast

Author: gengjiawen

interpreter/lib.rs

@@ -90,7 +90,7 @@ fn eval_expression(expression: &Expression, env: &Env) -> Result<Rc<Object>, Eva
             let args = eval_expressions(arguments, env)?;
             apply_function(&func, &args)
         }
-        Expression::Index(left, index) => {
+        Expression::Index(Index { object: left, index, .. }) => {
             let literal = eval_expression(left, &Rc::clone(env))?;
             let index = eval_expression(index, env)?;
             eval_index_expression(&literal, &index)

parser/ast.rs

@@ -83,14 +83,6 @@ 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),
@@ -100,7 +92,7 @@ pub enum Expression {
     IF(IF),
     FUNCTION(FunctionDeclaration),
     FunctionCall(FunctionCall),
-    Index(Box<Expression>, Box<Expression>),
+    Index(Index),
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, Eq, Hash, PartialEq)]
@@ -139,6 +131,21 @@ pub struct FunctionDeclaration {
     pub span: Span,
 }
 
+// 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 struct Index {
+    pub object: Box<Expression>,
+    pub index: Box<Expression>,
+    pub span: Span,
+}
+
 impl fmt::Display for Expression {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
@@ -172,8 +179,8 @@ impl fmt::Display for Expression {
             Expression::FunctionCall(FunctionCall { callee, arguments, .. }) => {
                 write!(f, "{}({})", callee, format_expressions(arguments))
             }
-            Expression::Index(left, index) => {
-                write!(f, "({}[{}])", left, index)
+            Expression::Index(Index { object, index, .. }) => {
+                write!(f, "({}[{}])", object, index)
             }
         }
     }

parser/ast_tree_test.rs

@@ -67,9 +67,17 @@ mod tests {
         test_ast_tree("test_func_declaration", input)
     }
 
+    // JS: https://astexplorer.net/#/gist/b263eabba126aba94f1ad1c00ccce45e/2eb24376e622e07cf04915ee7eea1bc1c49d6122
     #[test]
     fn test_func_call() {
         let input = "add(1, 2)";
         test_ast_tree("test_func_call", input)
     }
+
+    // JS: https://astexplorer.net/#/gist/785eba71d71896939d5e91e0d445d357/a7bc3d915da84c16313da691a42b4a410fc3eef0
+    #[test]
+    fn test_index() {
+        let input = "a[1]";
+        test_ast_tree("test_index", 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, FunctionCall};
+use crate::ast::{Program, Statement, Expression, Node, Literal, BlockStatement, Let, Integer, Boolean, StringType, Array, Hash, UnaryExpression, BinaryExpression, IDENTIFIER, IF, FunctionDeclaration, FunctionCall, Index};
 use crate::precedences::{Precedence, get_token_precedence};
 
 type ParseError = String;
@@ -410,12 +410,22 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_index_expression(&mut self, left: Expression) -> Result<Expression, ParseError> {
+        let start = self.current_token.span.start;
         self.next_token();
         let index = self.parse_expression(Precedence::LOWEST)?.0;
 
         self.expect_peek(&TokenKind::RBRACKET)?;
 
-        return Ok(Expression::Index(Box::new(left), Box::new(index)));
+        let end = self.current_token.span.end;
+
+        return Ok(Expression::Index(Index {
+            object: Box::new(left),
+            index: Box::new(index),
+            span: Span {
+                start,
+                end,
+            }
+        }));
     }
 
     fn parse_hash_expression(&mut self) -> Result<Expression, ParseError> {

parser/snapshots/parser__ast_tree_test__tests__test_index.snap

@@ -0,0 +1,38 @@
+---
+source: parser/ast_tree_test.rs
+expression: let_ast
+---
+{
+  "Program": {
+    "body": [
+      {
+        "type": "Expr",
+        "Index": {
+          "object": {
+            "IDENTIFIER": {
+              "name": "a",
+              "span": {
+                "start": 0,
+                "end": 1
+              }
+            }
+          },
+          "index": {
+            "LITERAL": {
+              "type": "Integer",
+              "raw": 1,
+              "span": {
+                "start": 2,
+                "end": 3
+              }
+            }
+          },
+          "span": {
+            "start": 1,
+            "end": 4
+          }
+        }
+      }
+    ]
+  }
+}