(fix) functions and blocks

Author: t-webber

src/errors/display.rs

@@ -10,7 +10,7 @@ pub fn display_errors(errors: Vec<CompileError>, files: &[(String, &str)], err_t
     }
     for error in errors {
         let (location, message, err_lvl, length) = error.get();
-        let (filename, line_nb, column_nb) = location.get();
+        let (filename, line_nb, column_nb) = location.into_values();
         let code_lines = files_status
             .get(&filename)
             .expect("Never happens: File of error doesn't exist");

src/errors/location.rs

@@ -10,8 +10,8 @@ pub struct Location {
 }
 
 impl Location {
-    pub(crate) fn get(self) -> (String, usize, usize) {
-        (self.file, self.line, self.col)
+    pub(crate) const fn get_values(&self) -> (&String, usize, usize) {
+        (&self.file, self.line, self.col)
     }
 
     pub(crate) fn incr_col(&mut self) {
@@ -34,6 +34,10 @@ impl Location {
         }
     }
 
+    pub(crate) fn into_values(self) -> (String, usize, usize) {
+        (self.file, self.line, self.col)
+    }
+
     pub(crate) fn to_error(&self, msg: String) -> CompileError {
         CompileError::from((self.to_owned(), msg, ErrorLevel::Error))
     }

src/errors/result.rs

@@ -30,12 +30,10 @@ impl<T: Default> Res<T> {
             errors: vec![err],
         }
     }
-}
 
-impl<T> Res<Option<T>> {
-    pub(crate) const fn from_errors(errors: Vec<CompileError>) -> Self {
+    pub(crate) fn from_errors(errors: Vec<CompileError>) -> Self {
         Self {
-            result: None,
+            result: T::default(),
             errors,
         }
     }

src/lexer/numbers/types.rs

@@ -105,14 +105,12 @@ impl NumberType {
             Self::Int => Self::UInt,
             Self::Long if signed => Self::LongLong,
             Self::Long => Self::ULong,
-            Self::LongLong if signed => return None,
-            Self::LongLong => Self::ULongLong,
-            Self::Float => Self::Double,
-            Self::Double => Self::LongDouble,
-            Self::LongDouble => return None,
+            Self::LongLong if !signed => Self::ULongLong,
             Self::UInt => Self::ULong,
             Self::ULong => Self::ULongLong,
-            Self::ULongLong => return None,
+            Self::ULongLong | Self::LongLong | Self::Float | Self::Double | Self::LongDouble => {
+                return None
+            }
         })
     }
 

src/lexer/types/tokens_types.rs

@@ -104,6 +104,10 @@ impl Token {
         }
     }
 
+    pub(crate) const fn get_location(&self) -> &Location {
+        &self.location
+    }
+
     #[inline]
     #[must_use]
     pub const fn get_value(&self) -> &TokenValue {

src/parser/parse_content.rs

@@ -1,7 +1,7 @@
 extern crate alloc;
 use alloc::vec::IntoIter;
 
-use super::state::ParsingState;
+use super::state::{BlockState, ParsingState};
 use super::symbols::handle_symbol;
 use super::tree::blocks::Block;
 use super::tree::node::Node;
@@ -37,6 +37,22 @@ fn handle_literal(
     parse_block(tokens, p_state, current)
 }
 
+fn mismatched_error(
+    blocks: &mut Vec<BlockState>,
+    next_token: Option<Token>,
+    filename: String,
+) -> Vec<CompileError> {
+    let mut errors = vec![];
+    let location = next_token.map_or_else(
+        || Location::from(filename),
+        |token| token.into_value_location().1,
+    );
+    while let Some(block) = blocks.pop() {
+        errors.push(block.mismatched_err_begin(location.clone()));
+    }
+    errors
+}
+
 #[expect(clippy::todo, reason = "implementation in process")]
 pub fn parse_block(
     tokens: &mut IntoIter<Token>,
@@ -68,13 +84,24 @@ pub fn parse_block(
 #[inline]
 pub fn parse_tokens(tokens: Vec<Token>) -> Res<Node> {
     let mut nodes = vec![];
+    let filename = tokens
+        .first()
+        .map(|node| node.get_location().get_values().0.to_owned());
     let mut tokens_iter = tokens.into_iter();
     while tokens_iter.len() != 0 {
         let mut outer_node_block = Node::default();
         let mut p_state = ParsingState::default();
         if let Err(err) = parse_block(&mut tokens_iter, &mut p_state, &mut outer_node_block) {
             return Res::from_err(err);
         }
+        if !p_state.opened_blocks.is_empty() {
+            return Res::from_errors(mismatched_error(
+                &mut p_state.opened_blocks,
+                tokens_iter.next(),
+                filename.expect("while loop never entered if tokens empty"),
+            ));
+        }
+
         nodes.push(outer_node_block);
     }
     Res::from(clean_nodes(nodes))

src/parser/state.rs

@@ -1,10 +1,37 @@
+use crate::errors::api::CompileError;
+use crate::Location;
+
 #[derive(PartialEq, Eq, Debug)]
 pub enum BlockState {
     Brace,
     Bracket,
     Parenthesis,
 }
 
+impl BlockState {
+    const fn get_delimiters(&self) -> (char, char) {
+        match self {
+            Self::Brace => ('{', '}'),
+            Self::Bracket => ('[', ']'),
+            Self::Parenthesis => ('(', ')'),
+        }
+    }
+
+    pub fn mismatched_err_begin(&self, location: Location) -> CompileError {
+        let (open, close) = self.get_delimiters();
+        location.into_error(format!(
+            "Mismatched '{close}'. Perhaps you forgot an opening '{open}'?"
+        ))
+    }
+
+    pub fn mismatched_err_end(&self, location: Location) -> CompileError {
+        let (open, close) = self.get_delimiters();
+        location.into_error(format!(
+            "Mismatched '{open}': reached end of block. Perhaps you forgot a closing '{close}'?"
+        ))
+    }
+}
+
 #[derive(Default, Debug)]
 pub struct ParsingState {
     pub opened_blocks: Vec<BlockState>,

src/parser/symbols/blocks.rs

@@ -52,7 +52,7 @@ pub fn blocks_handler(
                     .map_err(|err| location.into_error(err))?;
                 parse_block(tokens, p_state, current)
             } else {
-                Err(location.into_error(mismatched_err('(', ')')))
+                Err(BlockState::Parenthesis.mismatched_err_end(location))
             }
         }
         // bracket
@@ -73,7 +73,7 @@ pub fn blocks_handler(
                     parse_block(tokens, p_state, current)
                 }
             } else {
-                Err(location.into_error(mismatched_err('[', ']')))
+                Err(BlockState::Bracket.mismatched_err_end(location))
             }
         }
         // brace
@@ -114,7 +114,7 @@ fn handle_brace_block_open(
     let mut brace_block = Node::Block(Block::default());
     parse_block(tokens, p_state, &mut brace_block)?;
     if p_state.opened_blocks.pop() != Some(BlockState::Brace) {
-        return Err(location.into_error(mismatched_err('{', '}')));
+        return Err(BlockState::Brace.mismatched_err_end(location));
     }
     if let Node::Block(Block { full, .. }) = &mut brace_block {
         *full = true;
@@ -151,9 +151,3 @@ fn handle_colon(current: &mut Node) {
         /* last is empty: nothing to be done */
     }
 }
-
-fn mismatched_err(open: char, close: char) -> String {
-    format!(
-        "Mismatched {open}: You either forgot a closing {close} or there is an extra semi-colon."
-    )
-}

src/parser/tree/node.rs

@@ -381,8 +381,14 @@ impl Node {
                         }
                     }
                     Ordering::Equal => {
-                        // doing whatever works ?
-                        op.try_push_op_as_root(self)
+                        // doing whatever works ? no ! e.g.: !g(!x) gives !!g(x)
+                        // for `op.try_push_op_as_root(self)`
+                        if let Some(node) = arg {
+                            node.push_op(op)
+                        } else {
+                            *arg = Some(Box::from(op.try_to_node()?));
+                            Ok(())
+                        }
                     }
                 }
             }
@@ -440,7 +446,12 @@ impl Node {
             //
             //
             // success
-            Self::FunctionCall(FunctionCall { full: full @ false, .. }) => {*full = true; true }
+            Self::FunctionCall(FunctionCall { full: full @ false, args, .. }) => {
+                if !args.last_mut().is_some_and(Self::try_close_function) {
+                    *full = true; }
+                    true
+
+                }
             //
             //
             // failure