Add index operator for array

Author: luki446

examples/table.lua

@@ -1,3 +1,5 @@
-local t = { 1, 2, 3 }
+local t = { 123, 2, 3 }
 
-print("Table exists")
+print(t[1])
+print(t[2])
+print(t[3])

src/ast.rs

@@ -43,6 +43,7 @@ pub enum Expression {
     IdentifierExpression(String),
     BinaryExpression(Box<Expression>, String, Box<Expression>),
     FunctionCall(String, Vec<Expression>),
+    IndexOperator(Box<Expression>, Box<Expression>),
 }
 
 #[derive(Debug, Clone, PartialEq, PartialOrd)]
@@ -177,6 +178,18 @@ impl Expression {
                 }
                 Ok(EvalValue::Table(table))
             }
+            Expression::IndexOperator(table, index) => {
+                let table_value = table.execute(_g)?;
+                let index_value = index.execute(_g)?;
+                
+                match table_value {
+                    EvalValue::Table(table) => {
+                        Ok(table.get(&index_value).cloned().unwrap_or(EvalValue::Nil))
+                    }
+                    EvalValue::Nil => Ok(EvalValue::Nil),
+                    _ => Err("Cannot index non-table value".to_string())
+                }
+            }
         }
     }
 }

src/parser.rs

@@ -324,6 +324,13 @@ impl<'a> Parser<'a> {
                         tokens.next();
 
                         Ok(Expression::FunctionCall(identifier, arguments))
+                    } else if tokens.peek() == Some(&lex::Token::LeftSquareBracket) {
+                        tokens.next();
+                        let index = self.parse_expression(tokens)?;
+                        
+                        self.expect(tokens, lex::Token::RightSquareBracket)?;
+
+                        Ok(Expression::IndexOperator(Box::new(Expression::IdentifierExpression(identifier)), Box::new(index)))
                     } else {
                         Ok(Expression::IdentifierExpression(identifier))
                     }
@@ -439,7 +446,6 @@ impl<'a> Parser<'a> {
         &mut self,
         tokens: &mut std::iter::Peekable<std::vec::IntoIter<lex::Token>>,
     ) -> Result<Expression, String> {
-        tokens.next();
 
         let mut table_structure = BTreeMap::new();
         let mut in_table_index = 1;
@@ -454,8 +460,7 @@ impl<'a> Parser<'a> {
                 } // Skip comma
                 _ => {
                     let element = self.parse_expression(tokens)?;
-                    table_structure
-                        .insert(Expression::NumberLiteral(in_table_index as f64), element);
+                    table_structure.insert(Expression::NumberLiteral(in_table_index as f64), element);
                     in_table_index += 1;
                 }
             }