(tree) rev: block handlers

Author: t-webber

src/errors/result.rs

@@ -1,8 +1,9 @@
 use core::{convert, ops};
 
 use super::compile::CompileError;
-use crate::prelude::display_errors;
+use crate::errors::display::display_errors;
 
+#[derive(Debug)]
 pub struct Res<T> {
     errors: Vec<CompileError>,
     result: T,
@@ -34,7 +35,7 @@ impl<T> Res<T> {
             self.result
         } else {
             display_errors(self.errors, files, err_type);
-            panic!()
+            panic!(/* Fail when displaying errors */)
         }
     }
 

src/lib.rs

@@ -58,7 +58,6 @@ mod parser;
 
 #[allow(clippy::pub_use, unused_imports)]
 pub mod prelude {
-    pub use crate::errors::display::display_errors;
     pub use crate::errors::location::Location;
     pub use crate::errors::result::Res;
     pub use crate::lexer::api::{number_types, tokens_types};

src/parser/mod.rs

@@ -32,7 +32,6 @@ fn parse_block(
     current: &mut Node,
 ) -> Result<(), CompileError> {
     tokens.next().map_or(Ok(()), |token| {
-        println!("Current = {current}\t\tToken = {token:?}");
         let (value, location) = token.into_value_location();
         match value {
             TokenValue::Char(ch) => {
@@ -55,6 +54,18 @@ fn parse_block(
     })
 }
 
+fn clean_nodes(nodes: Vec<Node>) -> Node {
+    let mut cleaned = nodes
+        .into_iter()
+        .filter(|node| *node != Node::Empty)
+        .collect::<Vec<_>>();
+    if cleaned.len() == 1 {
+        cleaned.pop().expect("len == 1")
+    } else {
+        Node::Block(cleaned)
+    }
+}
+
 #[must_use]
 #[inline]
 pub fn parse_tokens(tokens: Vec<Token>) -> Res<Node> {
@@ -68,5 +79,5 @@ pub fn parse_tokens(tokens: Vec<Token>) -> Res<Node> {
         }
         nodes.push(outer_node_block);
     }
-    Res::from(Node::Block(nodes))
+    Res::from(clean_nodes(nodes))
 }

src/parser/state.rs

@@ -1,11 +1,11 @@
-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Debug)]
 pub enum Block {
     Parenthesis,
     Brace,
     Bracket,
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct ParsingState {
     pub wanting_colon: bool,
     pub opened_blocks: Vec<Block>,

src/parser/symbols.rs

@@ -6,7 +6,7 @@ use super::state::{Block, ParsingState};
 use super::tree::binary::BinaryOperator;
 use super::tree::node::Node;
 use super::tree::unary::UnaryOperator;
-use crate::errors::compile::{as_error, to_error, CompileError};
+use crate::errors::compile::{as_error, CompileError};
 use crate::errors::location::Location;
 use crate::lexer::api::tokens_types::{Symbol, Token};
 use crate::parser::parse_block;
@@ -31,27 +31,12 @@ fn handle_double_unary(
         .map_or_else(|_| current.push_op(second), |()| Ok(()))
 }
 
-fn handle_brace_open(current: &mut Node) -> Result<TodoState, String> {
-    let res = current.can_push_list_initialiser();
-    println!("BRACE OPEN = {res:?}");
-    match res {
-        Err(op) => Err(format!(
-            "Found operator '{op}' applied on list initialiser '{{}}', but this is not allowed."
-        )),
-        Ok(true) => {
-            current.push_block_as_leaf(Node::ListInitialiser(ListInitialiser::default()))?;
-            Ok(TodoState::None)
-        }
-        Ok(false) => Ok(TodoState::OpenBraceBlock),
-    }
-}
-
 // TODO: check for nested
-enum TodoState {
+enum BlockState {
     None,
     OpenBraceBlock,
     CloseBraceBlock,
-    EndBlock,
+    SemiColon,
     OpenParens,
     CloseParens,
     OpenBracket,
@@ -64,7 +49,7 @@ fn handle_one_symbol(
     symbol: &Symbol,
     current: &mut Node,
     p_state: &ParsingState,
-) -> Result<TodoState, String> {
+) -> Result<BlockState, String> {
     #[allow(clippy::enum_glob_use)]
     use Symbol::*;
     match symbol {
@@ -125,29 +110,15 @@ fn handle_one_symbol(
         Interrogation => current.push_op(TernaryOperator)?,
         Colon => current.handle_colon()?,
         // braces & blocks
-        BraceOpen => return handle_brace_open(current),
-        BraceClose => {
-            let res = current.edit_list_initialiser(&|_, full| *full = true);
-            println!("BRACE CLOSE = {res:?}");
-            if res.is_err() {
-                return Ok(TodoState::CloseBraceBlock);
-            }
-        }
-        BracketOpen => return Ok(TodoState::OpenBracket),
-        BracketClose => return Ok(TodoState::CloseBracket),
-        ParenthesisOpen => {
-            if !current.try_make_function() {
-                return Ok(TodoState::OpenParens);
-            }
-        }
-        ParenthesisClose => {
-            if !current.try_close_function() {
-                return Ok(TodoState::CloseParens);
-            }
-        }
-        SemiColon => return Ok(TodoState::EndBlock),
+        BraceOpen => return Ok(BlockState::OpenBraceBlock),
+        BraceClose => return Ok(BlockState::CloseBraceBlock),
+        BracketOpen => return Ok(BlockState::OpenBracket),
+        BracketClose => return Ok(BlockState::CloseBracket),
+        ParenthesisOpen => return Ok(BlockState::OpenParens),
+        ParenthesisClose => return Ok(BlockState::CloseParens),
+        SemiColon => return Ok(BlockState::SemiColon),
     }
-    Ok(TodoState::None)
+    Ok(BlockState::None)
 }
 
 fn mismatched_err(open: char, close: char) -> String {
@@ -156,22 +127,33 @@ fn mismatched_err(open: char, close: char) -> String {
     )
 }
 
-pub fn handle_symbol(
-    symbol: &Symbol,
+fn blocks_handler(
     current: &mut Node,
-    p_state: &mut ParsingState,
     tokens: &mut IntoIter<Token>,
+    p_state: &mut ParsingState,
     location: Location,
+    block_state: &BlockState,
 ) -> Result<(), CompileError> {
-    match handle_one_symbol(symbol, current, p_state).map_err(|err| to_error!(location, "{err}"))? {
+    match block_state {
         // semi-colon
-        TodoState::EndBlock => Ok(()),
+        BlockState::SemiColon => {
+            if let Node::Block(block) = current
+                && !block.last().is_none_or(|node| *node == Node::Empty)
+                {
+                block.push(Node::Empty);
+            } else if *current != Node::Empty {
+                *current = Node::Block(vec![mem::take(current), Node::Empty]);
+            } else {
+                /* last is empty: nothing to be done */
+            }
+            parse_block(tokens, p_state, current)
+        }
         // parenthesis
-        TodoState::CloseParens => {
+        BlockState::CloseParens if !current.try_close_function() => {
             p_state.opened_blocks.push(Block::Parenthesis);
             Ok(())
         }
-        TodoState::OpenParens => {
+        BlockState::OpenParens if !current.try_make_function() => {
             let mut parenthesized_block = Node::Empty;
             parse_block(tokens, p_state, &mut parenthesized_block)?;
             if p_state.opened_blocks.pop() == Some(Block::Parenthesis) {
@@ -180,45 +162,81 @@ pub fn handle_symbol(
                     .map_err(|err| as_error!(location, "{err}"))?;
                 parse_block(tokens, p_state, current)
             } else {
-                Err(to_error!(location, "{}", mismatched_err('(', ')')))
+                Err(as_error!(location, "{}", mismatched_err('(', ')')))
             }
         }
-        TodoState::None => parse_block(tokens, p_state, current),
         // bracket
-        TodoState::CloseBracket => {
+        BlockState::CloseBracket => {
             p_state.opened_blocks.push(Block::Bracket);
             Ok(())
         }
-        TodoState::OpenBracket => {
+        BlockState::OpenBracket => {
             let mut bracket_node = Node::Empty;
             parse_block(tokens, p_state, &mut bracket_node)?;
             if p_state.opened_blocks.pop() == Some(Block::Bracket) {
-                current
-                    .push_op(BOp::ArraySubscript)
-                    .map_err(|err| to_error!(location, "{err}"))?;
-                current
+                if let Err(err) = current.push_op(BOp::ArraySubscript) { Err(as_error!(location, "{err}")) } else {
+                    current
                     .push_block_as_leaf(bracket_node)
-                    .map_err(|err| to_error!(location, "{err}"))?;
-                parse_block(tokens, p_state, current)
+                    .map_err(|err| as_error!(location, "{err}"))?;
+                    parse_block(tokens, p_state, current)
+                }
             } else {
-                Err(to_error!(location, "{}", mismatched_err('[', ']')))
+                Err(as_error!(location, "{}", mismatched_err('[', ']')))
             }
         }
         // brace
-        TodoState::CloseBraceBlock => {
+        BlockState::CloseBraceBlock
+            if current
+                .edit_list_initialiser(&|_, full| *full = true)
+                .is_err() =>
+        {
             p_state.opened_blocks.push(Block::Brace);
             Ok(())
         }
-        TodoState::OpenBraceBlock => {
-            let mut brace_block = Node::Empty;
-            parse_block(tokens, p_state, &mut brace_block)?;
-            if p_state.opened_blocks.pop() == Some(Block::Brace) {
-                let old = mem::take(current);
-                *current = Node::Block(vec![old, brace_block]);
-                parse_block(tokens, p_state, current)
-            } else {
-                Err(to_error!(location, "{}", mismatched_err('{', '}')))
+        BlockState::OpenBraceBlock => {
+            match current.can_push_list_initialiser() {
+                Err(op) => Err(as_error!(location, "Found operator '{op}' applied on list initialiser '{{}}', but this is not allowed.")),
+                Ok(true) => {
+                    current.push_block_as_leaf(Node::ListInitialiser(ListInitialiser::default())).map_err(|err| as_error!(location, "{err}"))?;
+                    parse_block(tokens, p_state, current)
+                }
+                Ok(false) => {
+                    let mut brace_block = Node::Empty;
+                    parse_block(tokens, p_state, &mut brace_block)?;
+                    if p_state.opened_blocks.pop() == Some(Block::Brace) {
+                        if let Node::Block(vec) = current {
+                            vec.push(brace_block);
+                        } else if *current == Node::Empty {
+                            *current = brace_block;
+                        } else {
+                            *current =
+                                Node::Block(vec![mem::take(current), brace_block]);
+                        }
+                        parse_block(tokens, p_state, current)
+                    } else {
+                        Err(as_error!(location, "{}", mismatched_err('{', '}')))
+                    }
+
+                }
             }
         }
+        // others
+        BlockState::None
+        | BlockState::OpenParens
+        | BlockState::CloseParens
+        | BlockState::CloseBraceBlock => parse_block(tokens, p_state, current),
+    }
+}
+
+pub fn handle_symbol(
+    symbol: &Symbol,
+    current: &mut Node,
+    p_state: &mut ParsingState,
+    tokens: &mut IntoIter<Token>,
+    location: Location,
+) -> Result<(), CompileError> {
+    match handle_one_symbol(symbol, current, p_state) {
+        Err(err) => Err(as_error!(location, "{err}")),
+        Ok(block_state) => blocks_handler(current, tokens, p_state, location, &block_state),
     }
 }

src/parser/tree/conversions.rs

@@ -2,8 +2,9 @@ use core::mem;
 
 use super::binary::{Binary, BinaryOperator};
 use super::node::Node;
+use super::traits::Operator;
 use super::unary::{Unary, UnaryOperator};
-use super::{Operator, Ternary, TernaryOperator};
+use super::{Ternary, TernaryOperator};
 
 pub trait OperatorConversions: Operator
 where