From af34b3030a46805f42f04341f1ffb20d92fbb7ce Mon Sep 17 00:00:00 2001
From: Mel <einebeere@gmail.com>
Date: Sun, 24 Oct 2021 18:26:01 +0200
Subject: Array literals and array access

---
 src/parse/ast/expression.rs | 20 ++++++++++++++------
 src/parse/ast/nodes.rs      |  9 +++++++--
 src/parse/parser.rs         | 27 +++++++++++++++++++++++----
 3 files changed, 44 insertions(+), 12 deletions(-)

(limited to 'src/parse')

diff --git a/src/parse/ast/expression.rs b/src/parse/ast/expression.rs
index 1eec69d..b2b9678 100644
--- a/src/parse/ast/expression.rs
+++ b/src/parse/ast/expression.rs
@@ -1,8 +1,8 @@
 use std::fmt::{self, Display, Formatter};
 
 use super::nodes::{
-    ArrayAccessNode, BinaryOperator, BlockNode, CallNode, FnNode, Identifier, IfNode, Literal,
-    LoopNode, MemberAccessNode, UnaryOperator,
+    ArrayAccessNode, ArrayNode, BinaryOperator, BlockNode, CallNode, FnNode, Identifier, IfNode,
+    LoopNode, MemberAccessNode, SimpleLiteral, UnaryOperator,
 };
 
 #[derive(Debug, Clone)]
@@ -21,10 +21,11 @@ pub enum Expression {
     MemberAccess(Box<MemberAccessNode>),
     Group(Box<Expression>),
     Block(Box<BlockNode>),
-    Fn(Box<FnNode>),
     If(Box<IfNode>),
     Loop(Box<LoopNode>),
-    Literal(Literal),
+    FnLiteral(Box<FnNode>),
+    ArrayLiteral(ArrayNode),
+    SimpleLiteral(SimpleLiteral),
     Identifier(Identifier),
 }
 
@@ -81,7 +82,7 @@ impl Expression {
             Expression::Block(block) => {
                 Self::block_fmt(f, block, depth + 1)?;
             }
-            Expression::Fn(node) => {
+            Expression::FnLiteral(node) => {
                 write!(f, "{}Fn (", pad)?;
 
                 // Write self receiver
@@ -107,7 +108,14 @@ impl Expression {
                 )?;
                 Self::block_fmt(f, &node.body, depth + 1)?;
             }
-            Expression::Literal(literal) => {
+            Expression::ArrayLiteral(node) => {
+                writeln!(f, "{}Array Literal:", pad)?;
+                for (i, c) in node.elements.iter().enumerate() {
+                    writeln!(f, "{}- Element {}:", pad, i)?;
+                    c.nested_fmt(f, depth + 1)?;
+                }
+            }
+            Expression::SimpleLiteral(literal) => {
                 writeln!(f, "{}Literal: {:?}", pad, literal)?;
             }
             Expression::Identifier(identifier) => {
diff --git a/src/parse/ast/nodes.rs b/src/parse/ast/nodes.rs
index 617a01c..bffaea3 100644
--- a/src/parse/ast/nodes.rs
+++ b/src/parse/ast/nodes.rs
@@ -57,14 +57,14 @@ impl UnaryOperator {
 }
 
 #[derive(Debug, Clone)]
-pub enum Literal {
+pub enum SimpleLiteral {
     Int(u32),
     Float(f32),
     Str(String),
     Bool(bool),
 }
 
-impl Literal {
+impl SimpleLiteral {
     pub fn from_token(token: Token) -> Self {
         match token.variant {
             Int(int) => Self::Int(int),
@@ -111,6 +111,11 @@ pub struct FnNode {
     pub body: BlockNode,
 }
 
+#[derive(Debug, Clone)]
+pub struct ArrayNode {
+    pub elements: Vec<Expression>,
+}
+
 #[derive(Debug, Clone)]
 pub struct FnHeader {
     pub has_self_receiver: bool,
diff --git a/src/parse/parser.rs b/src/parse/parser.rs
index 2083f75..a882f35 100644
--- a/src/parse/parser.rs
+++ b/src/parse/parser.rs
@@ -1,11 +1,11 @@
 use super::ast::expression::Expression;
-use super::ast::nodes::{LoopNode, UnaryOperator};
+use super::ast::nodes::{ArrayNode, LoopNode, UnaryOperator};
 use super::ast::statement::Statement;
 use super::ast::Program;
 use crate::lex::token::TokenVariant::*;
 use crate::parse::ast::nodes::{
     ArrayAccessNode, BinaryOperator, BlockNode, CallNode, ConditionalBlock, FnHeader, FnNode,
-    IfNode, Literal, MemberAccessNode, TypedIdentifier,
+    IfNode, MemberAccessNode, SimpleLiteral, TypedIdentifier,
 };
 use crate::{check, consume, consume_if, inner, lex::token::Token};
 use anyhow::{anyhow, Result};
@@ -227,7 +227,9 @@ impl<T: Iterator<Item = Token>> Parser<T> {
             match token.variant {
                 Int(_) | Float(_) | Str(_) | KeywordTrue | KeywordFalse => {
                     let literal = self.tokens.next().unwrap();
-                    Ok(Expression::Literal(Literal::from_token(literal)))
+                    Ok(Expression::SimpleLiteral(SimpleLiteral::from_token(
+                        literal,
+                    )))
                 }
                 Ident(_) => Ok(Expression::Identifier(inner!(
                     self.tokens.next().unwrap(),
@@ -235,7 +237,8 @@ impl<T: Iterator<Item = Token>> Parser<T> {
                 ))),
                 GroupOpen => Ok(Expression::Group(Box::new(self.group()?))),
                 BlockOpen => Ok(Expression::Block(Box::new(self.generic_block()?))),
-                KeywordFn => Ok(Expression::Fn(Box::new(self.function()?))),
+                ArrayOpen => Ok(Expression::ArrayLiteral(self.array()?)),
+                KeywordFn => Ok(Expression::FnLiteral(Box::new(self.function()?))),
                 KeywordIf => Ok(Expression::If(Box::new(self.conditional()?))),
                 KeywordLoop => Ok(Expression::Loop(Box::new(self.repeating()?))),
                 _ => Err(anyhow!("Unexpected token: {:?}", token.variant)),
@@ -252,6 +255,22 @@ impl<T: Iterator<Item = Token>> Parser<T> {
         Ok(expression)
     }
 
+    fn array(&mut self) -> Result<ArrayNode> {
+        consume!(self, ArrayOpen)?;
+        let mut elements = Vec::new();
+
+        loop {
+            elements.push(self.expression()?);
+
+            if consume_if!(self, Comma).is_none() {
+                break;
+            }
+        }
+
+        consume!(self, ArrayClose)?;
+        Ok(ArrayNode { elements })
+    }
+
     fn function(&mut self) -> Result<FnNode> {
         consume!(self, KeywordFn)?;
         let token = self.tokens.next().expect("Expected function header.");
-- 
cgit 1.4.1