Postfix parsing

2 files changed, 45 insertions, 1 deletions

diff --git a/src/parse/ast/expression.rs b/src/parse/ast/expression.rs
index c7f6d9b..1eec69d 100644
--- a/src/parse/ast/expression.rs
+++ b/src/parse/ast/expression.rs
@@ -1,7 +1,8 @@
 use std::fmt::{self, Display, Formatter};
 
 use super::nodes::{
-    BinaryOperator, BlockNode, FnNode, Identifier, IfNode, Literal, LoopNode, UnaryOperator,
+    ArrayAccessNode, BinaryOperator, BlockNode, CallNode, FnNode, Identifier, IfNode, Literal,
+    LoopNode, MemberAccessNode, UnaryOperator,
 };
 
 #[derive(Debug, Clone)]
@@ -15,6 +16,9 @@ pub enum Expression {
         op: UnaryOperator,
         right: Box<Expression>,
     },
+    Call(Box<CallNode>),
+    ArrayAccess(Box<ArrayAccessNode>),
+    MemberAccess(Box<MemberAccessNode>),
     Group(Box<Expression>),
     Block(Box<BlockNode>),
     Fn(Box<FnNode>),
@@ -48,6 +52,28 @@ impl Expression {
                 writeln!(f, "{}- Right:", pad)?;
                 right.nested_fmt(f, depth + 1)?;
             }
+            Expression::Call(node) => {
+                writeln!(f, "{}Function Call:", pad)?;
+                writeln!(f, "{}- Called:", pad)?;
+                node.called.nested_fmt(f, depth + 1)?;
+                for (i, e) in node.arguments.iter().enumerate() {
+                    writeln!(f, "{}- Argument {}:", pad, i)?;
+                    e.nested_fmt(f, depth + 1)?;
+                }
+            }
+            Expression::ArrayAccess(node) => {
+                writeln!(f, "{}Array Access:", pad)?;
+                writeln!(f, "{}- Array:", pad)?;
+                node.array.nested_fmt(f, depth + 1)?;
+                writeln!(f, "{}- Index:", pad)?;
+                node.index.nested_fmt(f, depth + 1)?;
+            }
+            Expression::MemberAccess(node) => {
+                writeln!(f, "{}Member Access:", pad)?;
+                writeln!(f, "{}- Object:", pad)?;
+                node.object.nested_fmt(f, depth + 1)?;
+                writeln!(f, "{}- Member Name: {}", pad, node.member_name)?;
+            }
             Expression::Group(node) => {
                 writeln!(f, "{}Group:", pad)?;
                 node.nested_fmt(f, depth + 1)?;
diff --git a/src/parse/ast/nodes.rs b/src/parse/ast/nodes.rs
index 2a4f7c0..617a01c 100644
--- a/src/parse/ast/nodes.rs
+++ b/src/parse/ast/nodes.rs
@@ -88,6 +88,24 @@ pub struct TypedIdentifier {
 }
 
 #[derive(Debug, Clone)]
+pub struct CallNode {
+    pub called: Expression,
+    pub arguments: Vec<Expression>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ArrayAccessNode {
+    pub array: Expression,
+    pub index: Expression,
+}
+
+#[derive(Debug, Clone)]
+pub struct MemberAccessNode {
+    pub object: Expression,
+    pub member_name: Identifier,
+}
+
+#[derive(Debug, Clone)]
 pub struct FnNode {
     pub header: FnHeader,
     pub body: BlockNode,