AST restructure

1 files changed, 64 insertions, 53 deletions

diff --git a/src/parse/ast/expression.rs b/src/parse/ast/expression.rs
index d119a71..e883aaa 100644
--- a/src/parse/ast/expression.rs
+++ b/src/parse/ast/expression.rs
@@ -1,34 +1,45 @@
 use std::fmt::{self, Display, Formatter};
 
-use crate::parse::ast::nodes::StrPart;
+use crate::lex::token::Location;
 
 use super::nodes::{
-    ArrayAccessNode, ArrayNode, BinaryOperator, BlockNode, CallNode, FnNode, Identifier, IfNode,
-    LoopNode, MemberAccessNode, SimpleLiteral, StrNode, UnaryOperator,
+    ArrayAccessExpression, ArrayExpression, BinaryOperatorNode, BlockExpression, CallExpression,
+    FnExpression, Identifier, IfExpression, LoopExpression, MemberAccessExpression,
+    SimpleLiteralNode, StrExpression, StrPartKind, UnaryOperatorNode,
 };
 
 #[derive(Debug, Clone)]
-pub enum Expression {
+pub struct Expression {
+    // TODO: Sometimes this location is duplicated for no reason,
+    // i.e. in the UnaryExpression, since the token for the UnaryOperatorNode
+    // will be the same as the location for the expression...
+    // Can we do something about it or is some duplication fine?
+    pub at: Location,
+    pub kind: ExpressionKind,
+}
+
+#[derive(Debug, Clone)]
+pub enum ExpressionKind {
     Binary {
         left: Box<Expression>,
-        op: BinaryOperator,
+        op: BinaryOperatorNode,
         right: Box<Expression>,
     },
     Unary {
-        op: UnaryOperator,
+        op: UnaryOperatorNode,
         right: Box<Expression>,
     },
-    Call(Box<CallNode>),
-    ArrayAccess(Box<ArrayAccessNode>),
-    MemberAccess(Box<MemberAccessNode>),
+    Call(Box<CallExpression>),
+    ArrayAccess(Box<ArrayAccessExpression>),
+    MemberAccess(Box<MemberAccessExpression>),
     Group(Box<Expression>),
-    Block(Box<BlockNode>),
-    If(Box<IfNode>),
-    Loop(Box<LoopNode>),
-    StrLiteral(Box<StrNode>),
-    FnLiteral(Box<FnNode>),
-    ArrayLiteral(ArrayNode),
-    SimpleLiteral(SimpleLiteral),
+    Block(Box<BlockExpression>),
+    If(Box<IfExpression>),
+    Loop(Box<LoopExpression>),
+    StrLiteral(Box<StrExpression>),
+    FnLiteral(Box<FnExpression>),
+    ArrayLiteral(ArrayExpression),
+    SimpleLiteral(SimpleLiteralNode),
     Identifier(Identifier),
 }
 
@@ -41,8 +52,8 @@ impl Display for Expression {
 impl Expression {
     pub(crate) fn nested_fmt(&self, f: &mut Formatter<'_>, depth: usize) -> fmt::Result {
         let pad = "  ".repeat(depth);
-        match self {
-            Expression::Binary { left, op, right } => {
+        match self.kind {
+            ExpressionKind::Binary { left, op, right } => {
                 writeln!(f, "{}Binary:", pad)?;
                 writeln!(f, "{}- Left:", pad)?;
                 left.nested_fmt(f, depth + 1)?;
@@ -50,63 +61,63 @@ impl Expression {
                 writeln!(f, "{}- Right:", pad)?;
                 right.nested_fmt(f, depth + 1)?;
             }
-            Expression::Unary { op, right } => {
+            ExpressionKind::Unary { op, right } => {
                 writeln!(f, "{}Unary:", pad)?;
                 writeln!(f, "{}- Operator: {:?}", pad, op)?;
                 writeln!(f, "{}- Right:", pad)?;
                 right.nested_fmt(f, depth + 1)?;
             }
-            Expression::Call(node) => {
+            ExpressionKind::Call(expr) => {
                 writeln!(f, "{}Function Call:", pad)?;
                 writeln!(f, "{}- Called:", pad)?;
-                node.called.nested_fmt(f, depth + 1)?;
-                for (i, e) in node.arguments.iter().enumerate() {
+                expr.called.nested_fmt(f, depth + 1)?;
+                for (i, e) in expr.arguments.iter().enumerate() {
                     writeln!(f, "{}- Argument {}:", pad, i)?;
                     e.nested_fmt(f, depth + 1)?;
                 }
             }
-            Expression::ArrayAccess(node) => {
+            ExpressionKind::ArrayAccess(expr) => {
                 writeln!(f, "{}Array Access:", pad)?;
                 writeln!(f, "{}- Array:", pad)?;
-                node.array.nested_fmt(f, depth + 1)?;
+                expr.array.nested_fmt(f, depth + 1)?;
                 writeln!(f, "{}- Index:", pad)?;
-                node.index.nested_fmt(f, depth + 1)?;
+                expr.index.nested_fmt(f, depth + 1)?;
             }
-            Expression::MemberAccess(node) => {
+            ExpressionKind::MemberAccess(expr) => {
                 writeln!(f, "{}Member Access:", pad)?;
                 writeln!(f, "{}- Object:", pad)?;
-                node.object.nested_fmt(f, depth + 1)?;
-                writeln!(f, "{}- Member Name: {}", pad, node.member_name)?;
+                expr.object.nested_fmt(f, depth + 1)?;
+                writeln!(f, "{}- Member Name: {}", pad, expr.member_name)?;
             }
-            Expression::Group(node) => {
+            ExpressionKind::Group(expr) => {
                 writeln!(f, "{}Group:", pad)?;
-                node.nested_fmt(f, depth + 1)?;
+                expr.nested_fmt(f, depth + 1)?;
             }
-            Expression::Block(block) => {
-                Self::block_fmt(f, block, depth + 1)?;
+            ExpressionKind::Block(expr) => {
+                Self::block_fmt(f, &expr, depth + 1)?;
             }
-            Expression::StrLiteral(node) => {
+            ExpressionKind::StrLiteral(expr) => {
                 writeln!(f, "{}Str:", pad)?;
-                for (i, statement) in node.parts.iter().enumerate() {
+                for (i, statement) in expr.parts.iter().enumerate() {
                     writeln!(f, "{}- {}:", pad, i)?;
-                    match statement {
-                        StrPart::Literal(literal) => {
+                    match statement.kind {
+                        StrPartKind::Literal(literal) => {
                             writeln!(f, "{}{}", "  ".repeat(depth + 1), literal.clone())
                         }
-                        StrPart::Embed(block) => block.nested_fmt(f, depth + 1),
+                        StrPartKind::Embed(block) => block.nested_fmt(f, depth + 1),
                     }?;
                 }
             }
-            Expression::FnLiteral(node) => {
+            ExpressionKind::FnLiteral(expr) => {
                 write!(f, "{}Fn (", pad)?;
 
                 // Write self receiver
-                if node.header.has_self_receiver {
+                if expr.header.has_self_receiver {
                     write!(f, "self, ")?;
                 }
 
                 // Write parameters
-                for p in node.header.parameters.iter() {
+                for p in expr.header.parameters.iter() {
                     write!(
                         f,
                         "{}: {}, ",
@@ -119,52 +130,52 @@ impl Expression {
                 writeln!(
                     f,
                     ") -> {}:",
-                    node.header.return_type.as_ref().unwrap_or(&"_".into())
+                    expr.header.return_type.as_ref().unwrap_or(&"_".into())
                 )?;
-                Self::block_fmt(f, &node.body, depth + 1)?;
+                Self::block_fmt(f, &expr.body, depth + 1)?;
             }
-            Expression::ArrayLiteral(node) => {
+            ExpressionKind::ArrayLiteral(expr) => {
                 writeln!(f, "{}Array Literal:", pad)?;
-                for (i, c) in node.elements.iter().enumerate() {
+                for (i, c) in expr.elements.iter().enumerate() {
                     writeln!(f, "{}- Element {}:", pad, i)?;
                     c.nested_fmt(f, depth + 1)?;
                 }
             }
-            Expression::SimpleLiteral(literal) => {
+            ExpressionKind::SimpleLiteral(literal) => {
                 writeln!(f, "{}Literal: {:?}", pad, literal)?;
             }
-            Expression::Identifier(identifier) => {
+            ExpressionKind::Identifier(identifier) => {
                 writeln!(f, "{}Identifier: {:?}", pad, identifier)?;
             }
-            Expression::If(node) => {
+            ExpressionKind::If(expr) => {
                 writeln!(f, "{}If:", pad)?;
-                for (i, c) in node.conditionals.iter().enumerate() {
+                for (i, c) in expr.conditionals.iter().enumerate() {
                     writeln!(f, "{}- Condition {}:", pad, i)?;
                     c.condition.nested_fmt(f, depth + 1)?;
                     writeln!(f, "{}- Body {}:", pad, i)?;
                     Self::block_fmt(f, &c.block, depth + 1)?;
                 }
-                if let Some(e) = &node.else_block {
+                if let Some(e) = &expr.else_block {
                     writeln!(f, "{}- Else:", pad)?;
                     Self::block_fmt(f, e, depth + 1)?;
                 }
             }
-            Expression::Loop(node) => {
+            ExpressionKind::Loop(expr) => {
                 writeln!(f, "{}Loop:", pad)?;
-                if let Some(loop_condition) = &node.condition {
+                if let Some(loop_condition) = &expr.condition {
                     writeln!(f, "{}- Condition:", pad)?;
                     loop_condition.nested_fmt(f, depth + 1)?;
                 }
 
                 writeln!(f, "{}- Body:", pad)?;
-                Self::block_fmt(f, &node.body, depth + 1)?;
+                Self::block_fmt(f, &expr.body, depth + 1)?;
             }
         }
 
         Ok(())
     }
 
-    fn block_fmt(f: &mut Formatter<'_>, block: &BlockNode, depth: usize) -> fmt::Result {
+    fn block_fmt(f: &mut Formatter<'_>, block: &BlockExpression, depth: usize) -> fmt::Result {
         let pad = "  ".repeat(depth);
         writeln!(f, "{}Block:", pad)?;
         for (i, statement) in block.statements.iter().enumerate() {