(parser) ref: separate modifiers from types

Author: t-webber

src/parser/keyword/attributes.rs

@@ -2,14 +2,15 @@
 
 use core::fmt;
 
-use super::super::tree::binary::Binary;
-use super::super::tree::blocks::Block;
-use super::super::tree::literal::{Literal, Variable};
-use super::super::tree::unary::Unary;
-use super::super::tree::{FunctionCall, ListInitialiser, Ternary};
+use super::super::types::binary::Binary;
+use super::super::types::blocks::Block;
+use super::super::types::literal::{Literal, Variable};
+use super::super::types::unary::Unary;
+use super::super::types::{FunctionCall, ListInitialiser};
 use super::Ast;
-use super::types::PushInNode;
+use super::sort::PushInNode;
 use crate::lexer::api::Keyword;
+use crate::parser::types::ternary::Ternary;
 
 macro_rules! define_attribute_keywords {
     ($($name:ident: $($variant:ident)*,)*) => {

src/parser/keyword/control_flow/keyword.rs

@@ -1,7 +1,7 @@
 use core::fmt;
 
+use super::super::super::types::Ast;
 use super::node::ControlFlowNode;
-use crate::parser::tree::ast::Ast;
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum ControlFlowKeyword {

src/parser/keyword/control_flow/mod.rs

@@ -4,9 +4,9 @@ pub mod node;
 use keyword::ControlFlowKeyword;
 use node::ControlFlowNode;
 
+use super::super::types::blocks::Block;
 use super::Ast;
-use super::types::PushInNode;
-use crate::parser::tree::blocks::Block;
+use super::sort::PushInNode;
 
 impl PushInNode for ControlFlowKeyword {
     fn push_in_node(self, node: &mut Ast) -> Result<(), String> {

src/parser/keyword/control_flow/node.rs

@@ -1,6 +1,6 @@
+use super::super::super::types::blocks::Block;
+use super::super::super::types::{Ast, ParensBlock};
 use super::keyword::ControlFlowKeyword;
-use crate::parser::tree::ast::{Ast, ParensBlock};
-use crate::parser::tree::blocks::Block;
 
 #[derive(Debug, PartialEq)]
 pub enum ControlFlowNode {

src/parser/keyword/functions.rs

@@ -1,8 +1,8 @@
 use core::fmt;
 
+use super::super::types::literal::{Literal, Variable};
 use super::Ast;
-use super::types::PushInNode;
-use crate::parser::tree::literal::{Literal, Variable};
+use super::sort::PushInNode;
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum FunctionKeyword {

src/parser/keyword/mod.rs

@@ -2,16 +2,16 @@ extern crate alloc;
 pub mod attributes;
 pub mod control_flow;
 pub mod functions;
-pub mod types;
+pub mod sort;
 
 use alloc::vec::IntoIter;
 
 use control_flow::is_node_case_context;
-use types::{KeywordParsing, PushInNode as _};
+use sort::{KeywordParsing, PushInNode as _};
 
 use super::parse_content::parse_block;
 use super::state::ParsingState;
-use super::tree::ast::Ast;
+use super::types::Ast;
 use crate::Location;
 use crate::errors::api::CompileError;
 use crate::lexer::api::{Keyword, Token};

src/parser/keyword/types.rs src/parser/keyword/sort.rssrc/parser/keyword/types.rs renamed to src/parser/keyword/sort.rs

@@ -1,9 +1,9 @@
-use super::super::tree::ast::Ast;
+use super::super::types::Ast;
+use super::super::types::literal::Literal;
 use super::attributes::{AttributeKeyword as Attr, UnsortedAttributeKeyword as UnsortedAttr};
 use super::control_flow::keyword::ControlFlowKeyword as CtrlFlow;
 use super::functions::FunctionKeyword as Func;
 use crate::lexer::api::Keyword;
-use crate::parser::tree::literal::Literal;
 
 pub enum KeywordParsing {
     Attr(Attr),

src/parser/mod.rs

@@ -5,7 +5,8 @@ pub mod api {
 }
 
 mod keyword;
+mod modifiers;
 mod parse_content;
 mod state;
 mod symbols;
-mod tree;
+mod types;

src/parser/tree/ast.rs src/parser/modifiers/ast.rssrc/parser/tree/ast.rs renamed to src/parser/modifiers/ast.rs

@@ -1,32 +1,16 @@
 use core::cmp::Ordering;
 use core::{fmt, mem};
 
-use super::binary::Binary;
-use super::blocks::Block;
+use super::super::types::binary::Binary;
+use super::super::types::blocks::Block;
+use super::super::types::literal::{Attribute, Literal, Variable, VariableName};
+use super::super::types::operator::{Associativity, Operator as _};
+use super::super::types::unary::Unary;
+use super::super::types::{FunctionCall, ListInitialiser};
 use super::conversions::OperatorConversions;
-use super::literal::{Attribute, Literal, Variable, VariableName};
-use super::traits::{Associativity, Operator as _};
-use super::unary::Unary;
-use super::{FunctionCall, ListInitialiser, Ternary};
 use crate::EMPTY;
-use crate::parser::keyword::control_flow::node::ControlFlowNode;
-
-/// Struct to represent the AST
-#[derive(Debug, Default, PartialEq)]
-pub enum Ast {
-    Binary(Binary),
-    Block(Block),
-    ControlFlow(ControlFlowNode),
-    #[default]
-    Empty,
-    FunctionCall(FunctionCall),
-    Leaf(Literal),
-    ListInitialiser(ListInitialiser),
-    ParensBlock(ParensBlock),
-    Ternary(Ternary),
-    Unary(Unary),
-    // TODO: CompoundLiteral(CompoundLiteral), Cast,  & SpecialUnary(SpecialUnary),
-}
+use crate::parser::types::Ast;
+use crate::parser::types::ternary::Ternary;
 
 impl Ast {
     /// Finds the leaf the most left possible, checks it is a variable and
@@ -133,9 +117,7 @@ impl Ast {
             //
             //
             // atomic: failure
-            Self::ParensBlock(ParensBlock(old)) => {
-                Err(successive_literal_error("Parenthesis group", old, node))
-            }
+            Self::ParensBlock(old) => Err(successive_literal_error("Parenthesis group", old, node)),
             Self::Leaf(old) => Err(successive_literal_error("Literal", old, node)),
             //
             //
@@ -339,36 +321,12 @@ impl fmt::Display for Ast {
             Self::Unary(val) => val.fmt(f),
             Self::Block(block) => block.fmt(f),
             Self::ListInitialiser(list_initialiser) => list_initialiser.fmt(f),
-            Self::ParensBlock(ParensBlock(node)) => write!(f, "({node})"),
+            Self::ParensBlock(parens) => parens.fmt(f),
             Self::ControlFlow(_) => todo!(),
         }
     }
 }
 
-/// Struct to represent parenthesis
-///
-/// The [`Ast`] is what is inside of the parenthesis.
-///
-/// # Examples
-///
-/// If the C source is `(x = 2)`, the node is a [`ParensBlock`] with value the
-/// [`Ast`] of `x=2`.
-#[derive(Debug, Default, PartialEq)]
-pub struct ParensBlock(Box<Ast>);
-
-impl ParensBlock {
-    /// Adds parenthesis around an [`Ast`].
-    ///
-    /// # Examples
-    ///
-    /// ```ignore
-    /// assert!(ParensBlock::make_parens_ast(Ast::Empty) == Ast::ParensBlock(Box::new(Ast::Empty)));
-    /// ```
-    pub fn make_parens_ast(node: Ast) -> Ast {
-        Ast::ParensBlock(Self(Box::new(node)))
-    }
-}
-
 /// Makes an error [`String`] for consecutive literals.
 ///
 /// If two consecutive literals are found, the [`crate::parser`] fails, and this

src/parser/tree/conversions.rs src/parser/modifiers/conversions.rssrc/parser/tree/conversions.rs renamed to src/parser/modifiers/conversions.rs

@@ -1,11 +1,11 @@
 use core::mem;
 
-use super::ast::Ast;
-use super::binary::{Binary, BinaryOperator};
+use super::super::types::Ast;
+use super::super::types::binary::{Binary, BinaryOperator};
+use super::super::types::operator::Operator;
+use super::super::types::unary::{Unary, UnaryOperator};
 use super::make_lhs::make_lhs;
-use super::traits::Operator;
-use super::unary::{Unary, UnaryOperator};
-use super::{Ternary, TernaryOperator};
+use crate::parser::types::ternary::{Ternary, TernaryOperator};
 
 #[expect(clippy::missing_trait_methods)]
 impl OperatorConversions for BinaryOperator {