From e621f13a226d297d5368f4c294a8549a93843934 Mon Sep 17 00:00:00 2001 From: Mel Date: Tue, 14 Dec 2021 00:08:13 +0100 Subject: AST restructure --- src/parse/ast/expression.rs | 117 ++++++++++++++++++++++++-------------------- 1 file changed, 64 insertions(+), 53 deletions(-) (limited to 'src/parse/ast/expression.rs') 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, - op: BinaryOperator, + op: BinaryOperatorNode, right: Box, }, Unary { - op: UnaryOperator, + op: UnaryOperatorNode, right: Box, }, - Call(Box), - ArrayAccess(Box), - MemberAccess(Box), + Call(Box), + ArrayAccess(Box), + MemberAccess(Box), Group(Box), - Block(Box), - If(Box), - Loop(Box), - StrLiteral(Box), - FnLiteral(Box), - ArrayLiteral(ArrayNode), - SimpleLiteral(SimpleLiteral), + Block(Box), + If(Box), + Loop(Box), + StrLiteral(Box), + FnLiteral(Box), + 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() { -- cgit 1.4.1